--- a/.eslintignore
+++ b/.eslintignore
@@ -72,26 +72,24 @@ mail/app/profile/channel-prefs.js
 mail/base/content/protovis-r2.6-modded.js
 mail/branding/nightly/thunderbird-branding.js
 mail/branding/thunderbird/thunderbird-branding.js
 # This file is split into two in order to keep it as a valid json file
 # for documentation purposes (policies.json) but to be accessed by the
 # code as a .jsm (schema.jsm)
 mail/components/enterprisepolicies/schemas/schema.jsm
 mail/components/im/all-im.js
+mail/extensions/openpgp/prefs/openpgp-prefs.js
 mail/locales/en-US/all-l10n.js
 mail/components/compose/texzilla/**
 mail/components/compose/composer.js
 
 # exclude MailConstants.jsm because: #filter subtitution
 mail/base/modules/MailConstants.jsm
 
-# openpgp exclusions, should get enabled, tracked in bug 1595319
-mail/extensions/openpgp/**
-
 # calendar/ exclusions
 
 # prefs files
 calendar/lightning/content/lightning.js
 calendar/providers/gdata/defaults/preferences.js
 calendar/timezones/preferences.js
 
 # third party library

--- a/mail/extensions/openpgp/content/BondOpenPGP.jsm
+++ b/mail/extensions/openpgp/content/BondOpenPGP.jsm
@@ -33,18 +33,16 @@ const getEnigmailPgpmimeHander = Enigmai
   "EnigmailPgpmimeHander"
 );
 const getRNP = EnigmailLazy.loader("enigmail/rnp.jsm", "RNP");
 const getEnigmailWindows = EnigmailLazy.loader(
   "enigmail/windows.jsm",
   "EnigmailWindows"
 );
 
-/* global APP_SHUTDOWN: false */
-
 var BondOpenPGP = {
   logException(exc) {
     try {
       Services.console.logStringMessage(exc.toString() + "\n" + exc.stack);
     } catch (x) {}
   },
 
   initDone: false,

--- a/mail/extensions/openpgp/content/am-enigprefs.xhtml
+++ b/mail/extensions/openpgp/content/am-enigprefs.xhtml
@@ -130,18 +130,16 @@
 
                 <checkbox id="openpgp.sendKeyWithMsg"
                             label="&enigmail.amPrefPgp.sendKeyWithMsg.label;"
                             checked="false"/>
               </vbox>
 
               <!-- Autocrypt tab -->
               <vbox flex="1" align="start">
-                <html:p id="enigmail_amPrefAutocryptDesc" onclick="Enigmail.edit.handleClick(event)"></html:p>
-
                 <checkbox id="enigmail_enableAutocrypt"
                     prefstring="mail.server.%serverkey%.enableAutocrypt"
                     preftype="bool" prefattribute="value"
                     observes="enigmail_bcEnablePgp"
                     oncommand="Enigmail.edit.enableAcSettings()"
                     label="&enigmail.enableAutocrypt.label;"/>
 
                 <checkbox id="enigmail_acPreferEncrypt"

--- a/mail/extensions/openpgp/content/modules/addrbook.jsm
+++ b/mail/extensions/openpgp/content/modules/addrbook.jsm
@@ -1,50 +1,46 @@
 /*
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-
 "use strict";
 
 var EXPORTED_SYMBOLS = ["EnigmailAddrbook"];
 
 /*
  * Functionality related to the Thunderbird address book
  *
  */
 
-
-
-
-
 const ABMANAGER = "@mozilla.org/abmanager;1";
 
 var EnigmailAddrbook = {
   /**
    * Look up the address book card for a given email address
    *
    * @param emailAddr: String - email address to find
    *
    * @return if found: Object:
    *           - card: nsIAbCard for found email address
    *           - directory: nsIAbDirectory of found card
    *         NULL if not found
    */
-  lookupEmailAddress: function(emailAddr) {
+  lookupEmailAddress(emailAddr) {
     let abm = Cc[ABMANAGER].getService(Ci.nsIAbManager);
 
     for (let abd of abm.directories) {
       try {
         let crd = abd.cardForEmailAddress(emailAddr);
-        if (crd) return {
-          directory: abd,
-          card: crd
-        };
-      }
-      catch (x) {}
+        if (crd) {
+          return {
+            directory: abd,
+            card: crd,
+          };
+        }
+      } catch (x) {}
     }
 
     return null;
-  }
+  },
 };

--- a/mail/extensions/openpgp/content/modules/amPrefsService.jsm
+++ b/mail/extensions/openpgp/content/modules/amPrefsService.jsm
@@ -1,73 +1,74 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 "use strict";
 
-const {
-  manager: Cm,
-  results: Cr,
-  Constructor: CC
-} = Components;
+const { manager: Cm } = Components;
 Cm.QueryInterface(Ci.nsIComponentRegistrar);
 
-const EnigmailCompat = ChromeUtils.import("chrome://openpgp/content/modules/compat.jsm").EnigmailCompat;
+const EnigmailCompat = ChromeUtils.import(
+  "chrome://openpgp/content/modules/compat.jsm"
+).EnigmailCompat;
+const Services = ChromeUtils.import("resource://gre/modules/Services.jsm")
+  .Services;
 
 const CATEGORY = "mailnews-accountmanager-extensions";
 const CATEGORY_ENTRY = "openpgp-account-manager-extension";
-const PREF_SERVICE_NAME = "@mozilla.org/accountmanager/extension;1?name=enigprefs";
+const PREF_SERVICE_NAME =
+  "@mozilla.org/accountmanager/extension;1?name=enigprefs";
 
 var EXPORTED_SYMBOLS = ["EnigmailAmPrefsService"];
 
 var EnigmailAmPrefsService = {
-  startup: function(reason) {
+  startup(reason) {
     try {
-      var catMan = Cc["@mozilla.org/categorymanager;1"].getService(Ci.nsICategoryManager);
-      catMan.addCategoryEntry(CATEGORY,
+      Services.catMan.addCategoryEntry(
+        CATEGORY,
         CATEGORY_ENTRY,
         PREF_SERVICE_NAME,
-        false, true);
+        false,
+        true
+      );
       this.factory = new Factory(EnigmailPrefService);
-    }
-    catch (ex) {}
+    } catch (ex) {}
   },
 
-  shutdown: function(reason) {
-    var catMan = Cc["@mozilla.org/categorymanager;1"].getService(Ci.nsICategoryManager);
-    catMan.deleteCategoryEntry(CATEGORY, CATEGORY_ENTRY, false);
+  shutdown(reason) {
+    Services.catMan.deleteCategoryEntry(CATEGORY, CATEGORY_ENTRY, false);
 
     if (this.factory) {
       this.factory.unregister();
     }
-  }
+  },
 };
 
 function EnigmailPrefService() {}
 
 EnigmailPrefService.prototype = {
   name: "enigprefs",
   chromePackageName: "openpgp",
   classID: Components.ID("{f2be6d32-ff3c-11e9-8e8b-00163e5e6c00}"),
   classDescription: "OpenPGP Account Manager Extension Service",
   contractID: PREF_SERVICE_NAME,
   QueryInterface: EnigmailCompat.generateQI(["nsIMsgAccountManagerExtension"]),
 
-  showPanel: function(server) {
+  showPanel(server) {
     // show Enigmail panel for POP3, IMAP, NNTP and "movemail" (unix) account types
     switch (server.type) {
       case "nntp":
       case "imap":
       case "pop3":
       case "movemail":
         return true;
     }
     return false;
-  }
+  },
 };
 
 class Factory {
   constructor(component) {
     this.component = component;
     this.register();
     Object.freeze(this);
   }
@@ -75,18 +76,20 @@ class Factory {
   createInstance(outer, iid) {
     if (outer) {
       throw Cr.NS_ERROR_NO_AGGREGATION;
     }
     return new this.component();
   }
 
   register() {
-    Cm.registerFactory(this.component.prototype.classID,
+    Cm.registerFactory(
+      this.component.prototype.classID,
       this.component.prototype.classDescription,
       this.component.prototype.contractID,
-      this);
+      this
+    );
   }
 
   unregister() {
     Cm.unregisterFactory(this.component.prototype.classID, this);
   }
 }

--- a/mail/extensions/openpgp/content/modules/app.jsm
+++ b/mail/extensions/openpgp/content/modules/app.jsm
@@ -3,69 +3,71 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
 "use strict";
 
 var EXPORTED_SYMBOLS = ["EnigmailApp"];
 
-const EnigmailLazy = ChromeUtils.import("chrome://openpgp/content/modules/lazy.jsm").EnigmailLazy;
-const getEnigmailLog = EnigmailLazy.loader("enigmail/log.jsm", "EnigmailLog");
+const Services = ChromeUtils.import("resource://gre/modules/Services.jsm")
+  .Services;
 
-const DIR_SERV_CONTRACTID = "@mozilla.org/file/directory_service;1";
-const ENIG_EXTENSION_GUID = "{847b3a00-7ab1-11d4-8f02-006008948af5}";
-const XPCOM_APPINFO = "@mozilla.org/xre/app-info;1";
+const EnigmailLazy = ChromeUtils.import(
+  "chrome://openpgp/content/modules/lazy.jsm"
+).EnigmailLazy;
+const getEnigmailLog = EnigmailLazy.loader("enigmail/log.jsm", "EnigmailLog");
 
 var EnigmailApp = {
   /**
    * Platform application name (e.g. Thunderbird)
    */
-  getName: function() {
-    return Cc[XPCOM_APPINFO].getService(Ci.nsIXULAppInfo).name;
+  getName() {
+    return Services.appinfo.name;
   },
 
   /**
    * Platform (Gecko) version number (e.g. 42.0)
    * The platform version for SeaMonkey and for Thunderbird are identical
    * (unlike the application version numbers)
    */
-  getPlatformVersion: function() {
-    return Cc[XPCOM_APPINFO].getService(Ci.nsIXULAppInfo).platformVersion;
+  getPlatformVersion() {
+    return Services.appinfo.platformVersion;
   },
 
   /**
    * Return the directory holding the current profile as nsIFile object
    */
-  getProfileDirectory: function() {
-    let ds = Cc[DIR_SERV_CONTRACTID].getService(Ci.nsIProperties);
-    return ds.get("ProfD", Ci.nsIFile);
+  getProfileDirectory() {
+    return Services.dirsvc.get("ProfD", Ci.nsIFile);
   },
 
   /**
    * Get Enigmail version
    */
-  getVersion: function() {
+  getVersion() {
     getEnigmailLog().DEBUG("app.jsm: getVersion\n");
-    getEnigmailLog().DEBUG("app.jsm: installed version: " + EnigmailApp._version + "\n");
+    getEnigmailLog().DEBUG(
+      "app.jsm: installed version: " + EnigmailApp._version + "\n"
+    );
     return EnigmailApp._version;
   },
 
   /**
    * Get Enigmail installation directory
    */
-  getInstallLocation: function() {
+  getInstallLocation() {
     return EnigmailApp._installLocation;
   },
 
-  setVersion: function(version) {
+  setVersion(version) {
     EnigmailApp._version = version;
   },
 
-  setInstallLocation: function(location) {
+  setInstallLocation(location) {
     EnigmailApp._installLocation = location;
   },
 
-  initAddon: function() {
+  initAddon() {
     EnigmailApp.setVersion(0);
     EnigmailApp.setInstallLocation(0);
-  }
+  },
 };

--- a/mail/extensions/openpgp/content/modules/armor.jsm
+++ b/mail/extensions/openpgp/content/modules/armor.jsm
@@ -1,22 +1,24 @@
 /*
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-
 "use strict";
 
 var EXPORTED_SYMBOLS = ["EnigmailArmor"];
 
-const EnigmailConstants = ChromeUtils.import("chrome://openpgp/content/modules/constants.jsm").EnigmailConstants;
-const EnigmailLog = ChromeUtils.import("chrome://openpgp/content/modules/log.jsm").EnigmailLog;
-
+const EnigmailConstants = ChromeUtils.import(
+  "chrome://openpgp/content/modules/constants.jsm"
+).EnigmailConstants;
+const EnigmailLog = ChromeUtils.import(
+  "chrome://openpgp/content/modules/log.jsm"
+).EnigmailLog;
 
 // Locates STRing in TEXT occurring only at the beginning of a line
 function indexOfArmorDelimiter(text, str, offset) {
   let currentOffset = offset;
 
   while (currentOffset < text.length) {
     let loc = text.indexOf(str, currentOffset);
 
@@ -29,28 +31,26 @@ function indexOfArmorDelimiter(text, str
 
   return -1;
 }
 
 function searchBlankLine(str, then) {
   var offset = str.search(/\n\s*\r?\n/);
   if (offset === -1) {
     return "";
-  } else {
-    return then(offset);
   }
+  return then(offset);
 }
 
 function indexOfNewline(str, off, then) {
   var offset = str.indexOf("\n", off);
   if (offset === -1) {
     return "";
-  } else {
-    return then(offset);
   }
+  return then(offset);
 }
 
 var EnigmailArmor = {
   /**
    * Locates offsets bracketing PGP armored block in text,
    * starting from given offset, and returns block type string.
    *
    * @param text:          String - ASCII armored text
@@ -58,72 +58,110 @@ var EnigmailArmor = {
    * @param indentStr:     String - prefix that is used for all lines (such as "> ")
    * @param beginIndexObj: Object - o.value will contain offset of first character of block
    * @param endIndexObj:   Object - o.value will contain offset of last character of block (newline)
    * @param indentStrObj:  Object - o.value will contain indent of 1st line
    *
    * @return String - type of block found (e.g. MESSAGE, PUBLIC KEY)
    *           If no block is found, an empty String is returned;
    */
-  locateArmoredBlock: function(text, offset, indentStr, beginIndexObj, endIndexObj, indentStrObj) {
-    EnigmailLog.DEBUG("armor.jsm: Enigmail.locateArmoredBlock: " + offset + ", '" + indentStr + "'\n");
+  locateArmoredBlock(
+    text,
+    offset,
+    indentStr,
+    beginIndexObj,
+    endIndexObj,
+    indentStrObj
+  ) {
+    EnigmailLog.DEBUG(
+      "armor.jsm: Enigmail.locateArmoredBlock: " +
+        offset +
+        ", '" +
+        indentStr +
+        "'\n"
+    );
 
     beginIndexObj.value = -1;
     endIndexObj.value = -1;
 
-    var beginIndex = indexOfArmorDelimiter(text, indentStr + "-----BEGIN PGP ", offset);
+    var beginIndex = indexOfArmorDelimiter(
+      text,
+      indentStr + "-----BEGIN PGP ",
+      offset
+    );
 
     if (beginIndex == -1) {
       var blockStart = text.indexOf("-----BEGIN PGP ");
       if (blockStart >= 0) {
         var indentStart = text.search(/\n.*-----BEGIN PGP /) + 1;
         indentStrObj.value = text.substring(indentStart, blockStart);
         indentStr = indentStrObj.value;
-        beginIndex = indexOfArmorDelimiter(text, indentStr + "-----BEGIN PGP ", offset);
+        beginIndex = indexOfArmorDelimiter(
+          text,
+          indentStr + "-----BEGIN PGP ",
+          offset
+        );
       }
     }
 
-    if (beginIndex == -1)
+    if (beginIndex == -1) {
       return "";
+    }
 
     // Locate newline at end of armor header
     offset = text.indexOf("\n", beginIndex);
 
-    if (offset == -1)
+    if (offset == -1) {
       return "";
+    }
 
-    var endIndex = indexOfArmorDelimiter(text, indentStr + "-----END PGP ", offset);
+    var endIndex = indexOfArmorDelimiter(
+      text,
+      indentStr + "-----END PGP ",
+      offset
+    );
 
-    if (endIndex == -1)
+    if (endIndex == -1) {
       return "";
+    }
 
     // Locate newline at end of PGP block
     endIndex = text.indexOf("\n", endIndex);
 
     if (endIndex == -1) {
       // No terminating newline
       endIndex = text.length - 1;
     }
 
     var blockHeader = text.substr(beginIndex, offset - beginIndex + 1);
 
-    var blockRegex = new RegExp("^" + indentStr +
-      "-----BEGIN PGP (.{1,30})-----\\s*\\r?\\n");
+    var blockRegex = new RegExp(
+      "^" + indentStr + "-----BEGIN PGP (.{1,30})-----\\s*\\r?\\n"
+    );
 
     var matches = blockHeader.match(blockRegex);
 
     var blockType = "";
-    if (matches && (matches.length > 1)) {
+    if (matches && matches.length > 1) {
       blockType = matches[1];
-      EnigmailLog.DEBUG("armor.jsm: Enigmail.locateArmoredBlock: blockType=" + blockType + "\n");
+      EnigmailLog.DEBUG(
+        "armor.jsm: Enigmail.locateArmoredBlock: blockType=" + blockType + "\n"
+      );
     }
 
     if (blockType == "UNVERIFIED MESSAGE") {
       // Skip any unverified message block
-      return EnigmailArmor.locateArmoredBlock(text, endIndex + 1, indentStr, beginIndexObj, endIndexObj, indentStrObj);
+      return EnigmailArmor.locateArmoredBlock(
+        text,
+        endIndex + 1,
+        indentStr,
+        beginIndexObj,
+        endIndexObj,
+        indentStrObj
+      );
     }
 
     beginIndexObj.value = beginIndex;
     endIndexObj.value = endIndex;
 
     return blockType;
   },
 
@@ -135,131 +173,158 @@ var EnigmailArmor = {
    * @return Array of objects with the following structure:
    *        obj.begin:     Number
    *        obj.end:       Number
    *        obj.indent:    String
    *        obj.blocktype: String
    *
    *       if no block was found, an empty array is returned
    */
-  locateArmoredBlocks: function(text) {
+  locateArmoredBlocks(text) {
     var beginObj = {};
     var endObj = {};
     var indentStrObj = {};
     var blocks = [];
     var i = 0;
     var b;
 
-    while ((b = EnigmailArmor.locateArmoredBlock(text, i, "", beginObj, endObj, indentStrObj)) !== "") {
+    while (
+      (b = EnigmailArmor.locateArmoredBlock(
+        text,
+        i,
+        "",
+        beginObj,
+        endObj,
+        indentStrObj
+      )) !== ""
+    ) {
       blocks.push({
         begin: beginObj.value,
         end: endObj.value,
         indent: indentStrObj.value ? indentStrObj.value : "",
-        blocktype: b
+        blocktype: b,
       });
 
       i = endObj.value;
     }
 
-    EnigmailLog.DEBUG("armor.jsm: locateArmorBlocks: Found " + blocks.length + " Blocks\n");
+    EnigmailLog.DEBUG(
+      "armor.jsm: locateArmorBlocks: Found " + blocks.length + " Blocks\n"
+    );
     return blocks;
   },
 
-  extractSignaturePart: function(signatureBlock, part) {
-    EnigmailLog.DEBUG("armor.jsm: Enigmail.extractSignaturePart: part=" + part + "\n");
+  extractSignaturePart(signatureBlock, part) {
+    EnigmailLog.DEBUG(
+      "armor.jsm: Enigmail.extractSignaturePart: part=" + part + "\n"
+    );
 
     return searchBlankLine(signatureBlock, function(offset) {
       return indexOfNewline(signatureBlock, offset + 1, function(offset) {
-        var beginIndex = signatureBlock.indexOf("-----BEGIN PGP SIGNATURE-----", offset + 1);
+        var beginIndex = signatureBlock.indexOf(
+          "-----BEGIN PGP SIGNATURE-----",
+          offset + 1
+        );
         if (beginIndex == -1) {
           return "";
         }
 
         if (part === EnigmailConstants.SIGNATURE_TEXT) {
-          return signatureBlock.substr(offset + 1, beginIndex - offset - 1).
-          replace(/^- -/, "-").
-          replace(/\n- -/g, "\n-").
-          replace(/\r- -/g, "\r-");
+          return signatureBlock
+            .substr(offset + 1, beginIndex - offset - 1)
+            .replace(/^- -/, "-")
+            .replace(/\n- -/g, "\n-")
+            .replace(/\r- -/g, "\r-");
         }
 
         return indexOfNewline(signatureBlock, beginIndex, function(offset) {
-          var endIndex = signatureBlock.indexOf("-----END PGP SIGNATURE-----", offset);
+          var endIndex = signatureBlock.indexOf(
+            "-----END PGP SIGNATURE-----",
+            offset
+          );
           if (endIndex == -1) {
             return "";
           }
 
           var signBlock = signatureBlock.substr(offset, endIndex - offset);
 
           return searchBlankLine(signBlock, function(armorIndex) {
             if (part == EnigmailConstants.SIGNATURE_HEADERS) {
               return signBlock.substr(1, armorIndex);
             }
 
-            return indexOfNewline(signBlock, armorIndex + 1, function(armorIndex) {
+            return indexOfNewline(signBlock, armorIndex + 1, function(
+              armorIndex
+            ) {
               if (part == EnigmailConstants.SIGNATURE_ARMOR) {
-                return signBlock.substr(armorIndex, endIndex - armorIndex).
-                replace(/\s*/g, "");
-              } else {
-                return "";
+                return signBlock
+                  .substr(armorIndex, endIndex - armorIndex)
+                  .replace(/\s*/g, "");
               }
+              return "";
             });
           });
         });
       });
     });
   },
 
   /**
    * Remove all headers from an OpenPGP Armored message and replace them
    * with a set of new headers.
    *
    * @param armorText: String - ASCII armored message
    * @param headers:   Object - key/value pairs of new headers to insert
    *
    * @return String - new armored message
    */
-  replaceArmorHeaders: function(armorText, headers) {
-
+  replaceArmorHeaders(armorText, headers) {
     let text = armorText.replace(/\r\n/g, "\n");
     let i = text.search(/\n/);
 
-    if (i < 0) return armorText;
+    if (i < 0) {
+      return armorText;
+    }
     let m = text.substr(0, i + 1);
 
     for (let j in headers) {
       m += j + ": " + headers[j] + "\n";
     }
 
     i = text.search(/\n\n/);
-    if (i < 0) return armorText;
+    if (i < 0) {
+      return armorText;
+    }
     m += text.substr(i + 1);
 
     return m;
   },
 
   /**
    * Get a list of all headers found in an armor message
    *
    * @param text String - ASCII armored message
    *
    * @return Object: key/value pairs of headers. All keys are in lowercase.
    */
-  getArmorHeaders: function(text) {
+  getArmorHeaders(text) {
     let headers = {};
     let b = this.locateArmoredBlocks(text);
 
     if (b.length === 0) {
       return headers;
     }
 
     let msg = text.substr(b[0].begin);
 
     let lx = new RegExp("\\n" + b[0].indent + "\\r?\\n");
     let hdrEnd = msg.search(lx);
-    if (hdrEnd < 0) return headers;
+    if (hdrEnd < 0) {
+      return headers;
+    }
 
     let lines = msg.substr(0, hdrEnd).split(/\r?\n/);
 
     let rx = new RegExp("^" + b[0].indent + "([^: ]+)(: )(.*)");
     // skip 1st line (ARMOR-line)
     for (let i = 1; i < lines.length; i++) {
       let m = lines[i].match(rx);
       if (m && m.length >= 4) {
@@ -268,26 +333,26 @@ var EnigmailArmor = {
     }
 
     return headers;
   },
 
   /**
    * Split armored blocks into an array of strings
    */
-  splitArmoredBlocks: function(keyBlockStr) {
+  splitArmoredBlocks(keyBlockStr) {
     let myRe = /-----BEGIN PGP (PUBLIC|PRIVATE) KEY BLOCK-----/g;
     let myArray;
     let retArr = [];
     let startIndex = -1;
     while ((myArray = myRe.exec(keyBlockStr)) !== null) {
       if (startIndex >= 0) {
         let s = keyBlockStr.substring(startIndex, myArray.index);
         retArr.push(s);
       }
       startIndex = myArray.index;
     }
 
     retArr.push(keyBlockStr.substring(startIndex));
 
     return retArr;
-  }
-};
\ No newline at end of file
+  },
+};

--- a/mail/extensions/openpgp/content/modules/attachment.jsm
+++ b/mail/extensions/openpgp/content/modules/attachment.jsm
@@ -1,19 +1,20 @@
 /*
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-
 "use strict";
 
 var EXPORTED_SYMBOLS = ["EnigmailAttachment"];
 
-const EnigmailCryptoAPI = ChromeUtils.import("chrome://openpgp/content/modules/cryptoAPI.jsm").EnigmailCryptoAPI;
+const EnigmailCryptoAPI = ChromeUtils.import(
+  "chrome://openpgp/content/modules/cryptoAPI.jsm"
+).EnigmailCryptoAPI;
 
 var EnigmailAttachment = {
-  getFileName: function(parent, byteData) {
+  getFileName(parent, byteData) {
     const cApi = EnigmailCryptoAPI();
     return cApi.sync(cApi.getFileName(parent, byteData));
-  }
+  },
 };

--- a/mail/extensions/openpgp/content/modules/autoSetup.jsm
+++ b/mail/extensions/openpgp/content/modules/autoSetup.jsm
@@ -8,171 +8,206 @@
 
 /**
  *  Module to determine the type of setup of the user, based on existing emails
  *  found in the inbox
  */
 
 var EXPORTED_SYMBOLS = ["EnigmailAutoSetup"];
 
-const EnigmailLog = ChromeUtils.import("chrome://openpgp/content/modules/log.jsm").EnigmailLog;
-const EnigmailLocale = ChromeUtils.import("chrome://openpgp/content/modules/locale.jsm").EnigmailLocale;
-const EnigmailAutocrypt = ChromeUtils.import("chrome://openpgp/content/modules/autocrypt.jsm").EnigmailAutocrypt;
-const EnigmailFuncs = ChromeUtils.import("chrome://openpgp/content/modules/funcs.jsm").EnigmailFuncs;
-const EnigmailWindows = ChromeUtils.import("chrome://openpgp/content/modules/windows.jsm").EnigmailWindows;
-const EnigmailDialog = ChromeUtils.import("chrome://openpgp/content/modules/dialog.jsm").EnigmailDialog;
-const EnigmailConstants = ChromeUtils.import("chrome://openpgp/content/modules/constants.jsm").EnigmailConstants;
-const EnigmailKeyRing = ChromeUtils.import("chrome://openpgp/content/modules/keyRing.jsm").EnigmailKeyRing;
-const EnigmailMime = ChromeUtils.import("chrome://openpgp/content/modules/mime.jsm").EnigmailMime;
-const EnigmailCompat = ChromeUtils.import("chrome://openpgp/content/modules/compat.jsm").EnigmailCompat;
+const EnigmailLog = ChromeUtils.import(
+  "chrome://openpgp/content/modules/log.jsm"
+).EnigmailLog;
+const EnigmailAutocrypt = ChromeUtils.import(
+  "chrome://openpgp/content/modules/autocrypt.jsm"
+).EnigmailAutocrypt;
+const EnigmailFuncs = ChromeUtils.import(
+  "chrome://openpgp/content/modules/funcs.jsm"
+).EnigmailFuncs;
+const EnigmailDialog = ChromeUtils.import(
+  "chrome://openpgp/content/modules/dialog.jsm"
+).EnigmailDialog;
+const EnigmailConstants = ChromeUtils.import(
+  "chrome://openpgp/content/modules/constants.jsm"
+).EnigmailConstants;
+const EnigmailKeyRing = ChromeUtils.import(
+  "chrome://openpgp/content/modules/keyRing.jsm"
+).EnigmailKeyRing;
+const EnigmailMime = ChromeUtils.import(
+  "chrome://openpgp/content/modules/mime.jsm"
+).EnigmailMime;
 const jsmime = ChromeUtils.import("resource:///modules/jsmime.jsm").jsmime;
-const EnigmailWks = ChromeUtils.import("chrome://openpgp/content/modules/webKey.jsm").EnigmailWks;
-const EnigmailTimer = ChromeUtils.import("chrome://openpgp/content/modules/timer.jsm").EnigmailTimer;
-const EnigmailStreams = ChromeUtils.import("chrome://openpgp/content/modules/streams.jsm").EnigmailStreams;
-const EnigmailGpg = ChromeUtils.import("chrome://openpgp/content/modules/gpg.jsm").EnigmailGpg;
+const EnigmailWks = ChromeUtils.import(
+  "chrome://openpgp/content/modules/webKey.jsm"
+).EnigmailWks;
+const EnigmailTimer = ChromeUtils.import(
+  "chrome://openpgp/content/modules/timer.jsm"
+).EnigmailTimer;
+const EnigmailStreams = ChromeUtils.import(
+  "chrome://openpgp/content/modules/streams.jsm"
+).EnigmailStreams;
+const EnigmailGpg = ChromeUtils.import(
+  "chrome://openpgp/content/modules/gpg.jsm"
+).EnigmailGpg;
 
 // Interfaces
-const nsIFolderLookupService = Ci.nsIFolderLookupService;
 const nsIMsgAccountManager = Ci.nsIMsgAccountManager;
-const nsIMsgAccount = Ci.nsIMsgAccount;
-const nsIMsgDBHdr = Ci.nsIMsgDBHdr;
 const nsIMessenger = Ci.nsIMessenger;
 const nsIMsgMessageService = Ci.nsIMsgMessageService;
-const nsIMsgFolder = Ci.nsIMsgFolder;
 
 /**
  * the determined setup type
  */
 var gDeterminedSetupType = {
-  value: EnigmailConstants.AUTOSETUP_NOT_INITIALIZED
+  value: EnigmailConstants.AUTOSETUP_NOT_INITIALIZED,
 };
 
 var EnigmailAutoSetup = {
-
-  getDeterminedSetupType: async function() {
-    if (gDeterminedSetupType.value === EnigmailConstants.AUTOSETUP_NOT_INITIALIZED) {
-      return await this.determinePreviousInstallType();
+  async getDeterminedSetupType() {
+    if (
+      gDeterminedSetupType.value === EnigmailConstants.AUTOSETUP_NOT_INITIALIZED
+    ) {
+      return this.determinePreviousInstallType();
     }
-    else
-      return gDeterminedSetupType;
+    return gDeterminedSetupType;
   },
 
   /**
    * Identify which type of setup the user had before Enigmail was (re-)installed
    *
    * @return Promise<Object> with:
    *   - value : For each case assigned value, see EnigmailConstants.AUTOSETUP_xxx values
    *   - acSetupMessage {nsIMsgDBHdr}  in case value === 1
    *   - msgHeaders {Object}           in case value === 2
    */
-  determinePreviousInstallType: function() {
-    let self = this;
+  determinePreviousInstallType() {
     gDeterminedSetupType = {
-      value: EnigmailConstants.AUTOSETUP_NOT_INITIALIZED
+      value: EnigmailConstants.AUTOSETUP_NOT_INITIALIZED,
     };
 
     return new Promise(async (resolve, reject) => {
       EnigmailLog.DEBUG("autoSetup.jsm: determinePreviousInstallType()\n");
 
       try {
-        let msgAccountManager = Cc["@mozilla.org/messenger/account-manager;1"].getService(nsIMsgAccountManager);
-        let folderService = Cc["@mozilla.org/mail/folder-lookup;1"].getService(nsIFolderLookupService);
+        let msgAccountManager = Cc[
+          "@mozilla.org/messenger/account-manager;1"
+        ].getService(nsIMsgAccountManager);
         let returnMsgValue = {
-          value: EnigmailConstants.AUTOSETUP_NO_HEADER
+          value: EnigmailConstants.AUTOSETUP_NO_HEADER,
         };
 
         var accounts = msgAccountManager.accounts;
 
         let msgHeaders = [];
-        let autocryptSetupMessage = {};
 
         // If no account, except Local Folders is configured
         if (accounts.length <= 1) {
           gDeterminedSetupType.value = EnigmailConstants.AUTOSETUP_NO_ACCOUNT;
           resolve(gDeterminedSetupType);
           return;
         }
 
         // Iterate through each account
 
         for (var i = 0; i < accounts.length; i++) {
           var account = accounts.queryElementAt(i, Ci.nsIMsgAccount);
           var accountMsgServer = account.incomingServer;
-          EnigmailLog.DEBUG(`autoSetup.jsm: determinePreviousInstallType: scanning account "${accountMsgServer.prettyName}"\n`);
+          EnigmailLog.DEBUG(
+            `autoSetup.jsm: determinePreviousInstallType: scanning account "${
+              accountMsgServer.prettyName
+            }"\n`
+          );
 
           let msgFolderArr = [];
 
           try {
             getMsgFolders(account.incomingServer.rootFolder, msgFolderArr);
-          }
-          catch (e) {
-            EnigmailLog.DEBUG("autoSetup.jsm: determinePreviousInstallType: Error: " + e + "\n");
+          } catch (e) {
+            EnigmailLog.DEBUG(
+              "autoSetup.jsm: determinePreviousInstallType: Error: " + e + "\n"
+            );
           }
 
           if (account.incomingServer.type.search(/^(none|nntp)$/) === 0) {
             // ignore NNTP accounts and "Local Folders" accounts
             continue;
           }
 
           // Iterating through each non empty Folder Database in the Account
 
           for (var k = 0; k < msgFolderArr.length; k++) {
             let msgFolder = msgFolderArr[k];
             let msgDatabase = msgFolderArr[k].msgDatabase;
 
-            if ((msgFolder.flags & Ci.nsMsgFolderFlags.Junk) ||
-              (msgFolder.flags & Ci.nsMsgFolderFlags.Trash) ||
-              (!account.defaultIdentity)) {
+            if (
+              msgFolder.flags & Ci.nsMsgFolderFlags.Junk ||
+              msgFolder.flags & Ci.nsMsgFolderFlags.Trash ||
+              !account.defaultIdentity
+            ) {
               continue;
             }
 
-            EnigmailLog.DEBUG(`autoSetup.jsm: determinePreviousInstallType: scanning folder "${msgFolder.name}"\n`);
+            EnigmailLog.DEBUG(
+              `autoSetup.jsm: determinePreviousInstallType: scanning folder "${
+                msgFolder.name
+              }"\n`
+            );
 
             // Iterating through each message in the Folder
             for (let msgHeader of msgDatabase.ReverseEnumerateMessages()) {
               let msgURI = msgFolder.getUriForMsg(msgHeader);
 
               let msgAuthor = "";
               try {
                 msgAuthor = EnigmailFuncs.stripEmail(msgHeader.author);
-              }
-              catch (x) {}
+              } catch (x) {}
 
               // Listing all the headers in the message
 
-              let messenger = Components.classes["@mozilla.org/messenger;1"].createInstance(nsIMessenger);
-              let mms = messenger.messageServiceFromURI(msgURI).QueryInterface(nsIMsgMessageService);
+              let messenger = Cc["@mozilla.org/messenger;1"].createInstance(
+                nsIMessenger
+              );
+              let mms = messenger
+                .messageServiceFromURI(msgURI)
+                .QueryInterface(nsIMsgMessageService);
 
               let headerObj = await getStreamedHeaders(msgURI, mms);
-              let checkHeaderValues = await checkHeaders(headerObj, msgHeader, msgAuthor, account.defaultIdentity.email, msgFolder, returnMsgValue, msgHeaders);
+              let checkHeaderValues = await checkHeaders(
+                headerObj,
+                msgHeader,
+                msgAuthor,
+                account.defaultIdentity.email,
+                msgFolder,
+                returnMsgValue,
+                msgHeaders
+              );
 
               msgHeaders = checkHeaderValues.msgHeaders;
               returnMsgValue = checkHeaderValues.returnMsgValue;
 
               const currDateInSeconds = getCurrentTime();
               const diffSecond = currDateInSeconds - msgHeader.dateInSeconds;
 
               /**
                   2592000 = No. of Seconds in a Month.
                   This is to ignore 1 month old messages.
               */
               if (diffSecond > 2592000.0) {
                 break;
               }
             }
-
           }
-
         }
         if (returnMsgValue.acSetupMessage) {
-          EnigmailLog.DEBUG(`autoSetup.jsm: determinePreviousInstallType: found AC-Setup message\n`);
+          EnigmailLog.DEBUG(
+            `autoSetup.jsm: determinePreviousInstallType: found AC-Setup message\n`
+          );
           gDeterminedSetupType = returnMsgValue;
           resolve(gDeterminedSetupType);
-        }
-        else {
+        } else {
           EnigmailLog.DEBUG(`msgHeaders.length: ${msgHeaders.length}\n`);
 
           // find newest message to know the protocol
           let latestMsg = null;
           for (let i = 0; i < msgHeaders.length; i++) {
             if (!latestMsg) {
               latestMsg = msgHeaders[i];
             }
@@ -181,63 +216,70 @@ var EnigmailAutoSetup = {
               latestMsg = msgHeaders[i];
             }
           }
 
           if (latestMsg) {
             if (latestMsg.msgType === "Autocrypt") {
               returnMsgValue.value = EnigmailConstants.AUTOSETUP_AC_HEADER;
               returnMsgValue.msgHeaders = msgHeaders;
-            }
-            else {
+            } else {
               returnMsgValue.value = EnigmailConstants.AUTOSETUP_ENCRYPTED_MSG;
               returnMsgValue.msgHeaders = msgHeaders;
             }
           }
 
           let defId = EnigmailFuncs.getDefaultIdentity();
           if (defId) {
             returnMsgValue.userName = defId.fullName;
             returnMsgValue.userEmail = defId.email;
-          }
-          else {
+          } else {
             returnMsgValue.userName = undefined;
             returnMsgValue.userEmail = undefined;
           }
 
           gDeterminedSetupType = returnMsgValue;
-          EnigmailLog.DEBUG(`autoSetup.jsm: determinePreviousInstallType: found type: ${returnMsgValue.value}\n`);
+          EnigmailLog.DEBUG(
+            `autoSetup.jsm: determinePreviousInstallType: found type: ${
+              returnMsgValue.value
+            }\n`
+          );
           resolve(returnMsgValue);
         }
-      }
-      catch (x) {
+      } catch (x) {
         reject(x);
       }
     });
-
   },
 
   /**
    * Process the Autocrypt Setup Message
    *
    * @param {Object} headerValue: contains header and attachment of an Autocrypt Setup Message
    * @param {nsIWindow} passwordWindow: parent window for password dialog
    * @param {nsIWindow} confirmWindow:  parent window for confirmation dialog
    *        (note: split into 2 parent windows for unit tests)
    *
    * @return {Promise<Number>}: Import result.
    *                  1: imported OK
    *                  0: no Autocrypt setup message
    *                 -1: import not OK (wrong password, canceled etc.)
    */
 
-  performAutocryptSetup: async function(headerValue, passwordWindow = null, confirmWindow = null) {
+  async performAutocryptSetup(
+    headerValue,
+    passwordWindow = null,
+    confirmWindow = null
+  ) {
     EnigmailLog.DEBUG("autoSetup.jsm: performAutocryptSetup()\n");
 
-    EnigmailDialog.alert(window, "EnigmailAutocrypt.handleBackupMessage not implemented");
+    EnigmailDialog.alert(
+      confirmWindow,
+      "EnigmailAutocrypt.handleBackupMessage not implemented"
+    );
 
     let imported = 0;
     /*
     if (headerValue.attachment.contentType.search(/^application\/autocrypt-setup$/i) === 0) {
       try {
         let res = await EnigmailAutocrypt.getSetupMessageData(headerValue.attachment.url);
         let passwd = EnigmailWindows.autocryptSetupPasswd(passwordWindow, "input", res.passphraseFormat, res.passphraseHint);
 
@@ -279,42 +321,45 @@ var EnigmailAutoSetup = {
   /**
    * Process accounts with Autocrypt headers
    *
    * @param {Object} setupType: containing Autocrypt headers from accounts
    *
    * @return {Promise<Number>}: Result: 0: OK / 1: failure
    */
 
-  processAutocryptHeader: function(setupType) {
+  processAutocryptHeader(setupType) {
     EnigmailLog.DEBUG("autoSetup.jsm: processAutocryptHeader()\n");
 
     return new Promise(async (resolve, reject) => {
-
       // find newest message to know the protocol
       let latestMsg = null;
       for (let i = 0; i < setupType.msgHeaders.length; i++) {
         if (!latestMsg) {
           latestMsg = setupType.msgHeaders[i];
         }
 
         if (setupType.msgHeaders[i].dateTime > latestMsg) {
           latestMsg = setupType.msgHeaders[i];
         }
       }
 
       let sysType = latestMsg.msgType;
-      EnigmailLog.DEBUG(`autoSetup.jsm: processAutocryptHeader: got type: ${sysType}\n`);
-
+      EnigmailLog.DEBUG(
+        `autoSetup.jsm: processAutocryptHeader: got type: ${sysType}\n`
+      );
 
       for (let i = 0; i < setupType.msgHeaders.length; i++) {
         if (setupType.msgHeaders[i].msgType === "Autocrypt") {
           // FIXME
-          let success = await EnigmailAutocrypt.processAutocryptHeader(setupType.msgHeaders[i].fromAddr, [setupType.msgHeaders[i].msgData],
-            setupType.msgHeaders[i].date);
+          let success = await EnigmailAutocrypt.processAutocryptHeader(
+            setupType.msgHeaders[i].fromAddr,
+            [setupType.msgHeaders[i].msgData],
+            setupType.msgHeaders[i].date
+          );
           if (success !== 0) {
             resolve(1);
           }
         }
       }
       resolve(0);
     });
   },
@@ -322,35 +367,41 @@ var EnigmailAutoSetup = {
   /**
    * Create a new autocrypt key for every configured account and configure the account
    * to use that key. The keys are not protected by a password.
    *
    * The creation is done in the background after waiting timeoutValue ms
    * @param {Number} timeoutValue: number of miliseconds to wait before starting
    *                               the process
    */
-  createKeyForAllAccounts: function(timeoutValue = 1000) {
+  createKeyForAllAccounts(timeoutValue = 1000) {
     EnigmailLog.DEBUG("autoSetup.jsm: createKeyForAllAccounts()\n");
     let self = this;
 
-    EnigmailTimer.setTimeout(async function _f() {
-      let msgAccountManager = Cc["@mozilla.org/messenger/account-manager;1"].getService(nsIMsgAccountManager);
+    EnigmailTimer.setTimeout(async function() {
+      let msgAccountManager = Cc[
+        "@mozilla.org/messenger/account-manager;1"
+      ].getService(nsIMsgAccountManager);
       let accounts = msgAccountManager.accounts;
       let createdKeys = [];
 
       for (let i = 0; i < accounts.length; i++) {
         let account = accounts.queryElementAt(i, Ci.nsIMsgAccount);
         let id = account.defaultIdentity;
 
         if (id && id.email) {
           let keyId = await self.createAutocryptKey(id.fullName, id.email);
-          EnigmailLog.DEBUG(`autoSetup.jsm: createKeyForAllAccounts: created key ${keyId}\n`);
+          EnigmailLog.DEBUG(
+            `autoSetup.jsm: createKeyForAllAccounts: created key ${keyId}\n`
+          );
           if (keyId) {
             let keyObj = EnigmailKeyRing.getKeyById(keyId);
-            if (keyObj) createdKeys.push(keyObj);
+            if (keyObj) {
+              createdKeys.push(keyObj);
+            }
             id.setBoolAttribute("enablePgp", true);
             id.setCharAttribute("pgpkeyId", keyId);
             id.setIntAttribute("pgpKeyMode", 1);
             id.setBoolAttribute("pgpMimeMode", true);
             id.setBoolAttribute("pgpSignEncrypted", true);
           }
         }
       }
@@ -364,17 +415,17 @@ var EnigmailAutoSetup = {
    * Create a new autocrypt-complinant key
    * The keys will not be protected by passwords.
    *
    * @param {String} userName:  Display name
    * @param {String} userEmail: Email address
    *
    * @return {Promise<Boolean>}: Success (true = successful)
    */
-  createAutocryptKey: function(userName, userEmail) {
+  createAutocryptKey(userName, userEmail) {
     return new Promise((resolve, reject) => {
       EnigmailLog.DEBUG("autoSetup.jsm: createAutocryptKey()\n");
 
       let keyType = "ECC",
         keyLength = 0;
 
       if (!EnigmailGpg.getGpgFeature("supports-ecc-keys")) {
         // fallback for gpg < 2.1
@@ -384,59 +435,74 @@ var EnigmailAutoSetup = {
 
       let expiry = 1825, // 5 years
         passphrase = "",
         generateObserver = {
           keyId: null,
           backupLocation: null,
           _state: 0,
 
-          onDataAvailable: function(data) {},
-          onStopRequest: function(exitCode) {
-            EnigmailLog.DEBUG("autoSetup.jsm: createAutocryptKey(): key generation complete\n");
+          onDataAvailable(data) {},
+          onStopRequest(exitCode) {
+            EnigmailLog.DEBUG(
+              "autoSetup.jsm: createAutocryptKey(): key generation complete\n"
+            );
             resolve(generateObserver.keyId);
-          }
+          },
         };
 
       try {
-        let keygenRequest = EnigmailKeyRing.generateKey(userName, "", userEmail, expiry, keyLength, keyType, passphrase, generateObserver);
-      }
-      catch (ex) {
-        EnigmailLog.DEBUG("autoSetup.jsm: createAutocryptKey: error: " + ex.message);
+        EnigmailKeyRing.generateKey(
+          userName,
+          "",
+          userEmail,
+          expiry,
+          keyLength,
+          keyType,
+          passphrase,
+          generateObserver
+        );
+      } catch (ex) {
+        EnigmailLog.DEBUG(
+          "autoSetup.jsm: createAutocryptKey: error: " + ex.message
+        );
         resolve(null);
       }
     });
   },
 
   /**
    * Configure Enigmail to use existing keys
    */
-  applyExistingKeys: function() {
-    let msgAccountManager = Cc["@mozilla.org/messenger/account-manager;1"].getService(nsIMsgAccountManager);
+  applyExistingKeys() {
+    let msgAccountManager = Cc[
+      "@mozilla.org/messenger/account-manager;1"
+    ].getService(nsIMsgAccountManager);
     let identities = msgAccountManager.allIdentities;
 
     for (let i = 0; i < identities.length; i++) {
       let id = identities.queryElementAt(i, Ci.nsIMsgIdentity);
 
       if (id && id.email) {
         let keyObj = EnigmailKeyRing.getSecretKeyByEmail(id.email);
         if (keyObj) {
-          EnigmailLog.DEBUG(`autoSetup.jsm: applyExistingKeys: found key ${keyObj.keyId}\n`);
+          EnigmailLog.DEBUG(
+            `autoSetup.jsm: applyExistingKeys: found key ${keyObj.keyId}\n`
+          );
           id.setBoolAttribute("enablePgp", true);
           id.setCharAttribute("pgpkeyId", "0x" + keyObj.fpr);
           id.setIntAttribute("pgpKeyMode", 1);
           id.setBoolAttribute("pgpMimeMode", true);
           id.setBoolAttribute("pgpSignEncrypted", true);
         }
       }
     }
-  }
+  },
 };
 
-
 /**
  * Recusrively go through all folders to get a flat array of all sub-folders
  * starting with a parent folder.
  *
  * @param {nsIMsgFolder} folder:       the folder to scan
  * @param {nsIMsgFolder} msgFolderArr: An array to be filled with all folders that contain messages
  */
 
@@ -455,199 +521,218 @@ function getMsgFolders(folder, msgFolder
 
 // Util Function for Extracting manually added Headers
 function streamListener(callback) {
   let streamListener = {
     mAttachments: [],
     mHeaders: [],
     mBusy: true,
 
-    onStartRequest: function(aRequest) {
+    onStartRequest(aRequest) {
       this.mAttachments = [];
       this.mHeaders = [];
       this.mBusy = true;
 
-      var channel = aRequest.QueryInterface(Components.interfaces.nsIChannel);
-      channel.URI.QueryInterface(Components.interfaces.nsIMsgMailNewsUrl);
+      var channel = aRequest.QueryInterface(Ci.nsIChannel);
+      channel.URI.QueryInterface(Ci.nsIMsgMailNewsUrl);
       channel.URI.msgHeaderSink = this; // adds this header sink interface to the channel
     },
-    onStopRequest: function(aRequest, aStatusCode) {
+    onStopRequest(aRequest, aStatusCode) {
       callback();
       this.mBusy = false; // if needed, you can poll this var to see if we are done collecting attachment details
     },
-    onDataAvailable: function(aRequest, aInputStream, aOffset, aCount) {},
-    onStartHeaders: function() {},
-    onEndHeaders: function() {},
-    processHeaders: function(aHeaderNameEnumerator, aHeaderValueEnumerator, aDontCollectAddress) {
+    onDataAvailable(aRequest, aInputStream, aOffset, aCount) {},
+    onStartHeaders() {},
+    onEndHeaders() {},
+    processHeaders(
+      aHeaderNameEnumerator,
+      aHeaderValueEnumerator,
+      aDontCollectAddress
+    ) {
       for (let headerName of aHeaderNameEnumerator) {
         this.mHeaders.push({
           name: headerName.toLowerCase(),
-          value: aHeaderValueEnumerator.getNext()
+          value: aHeaderValueEnumerator.getNext(),
         });
       }
     },
-    handleAttachment: function(aContentType, aUrl, aDisplayName, aUri, aIsExternalAttachment) {
+    handleAttachment(
+      aContentType,
+      aUrl,
+      aDisplayName,
+      aUri,
+      aIsExternalAttachment
+    ) {
       if (aContentType == "text/html") {
         return;
       }
       this.mAttachments.push({
         contentType: aContentType,
         url: aUrl,
         displayName: aDisplayName,
         uri: aUri,
-        isExternal: aIsExternalAttachment
+        isExternal: aIsExternalAttachment,
       });
     },
-    onEndAllAttachments: function() {},
-    onEndMsgDownload: function(aUrl) {},
-    onEndMsgHeaders: function(aUrl) {},
-    onMsgHasRemoteContent: function(aMsgHdr) {},
-    getSecurityInfo: function() {},
-    setSecurityInfo: function(aSecurityInfo) {},
-    getDummyMsgHeader: function() {},
+    onEndAllAttachments() {},
+    onEndMsgDownload(aUrl) {},
+    onEndMsgHeaders(aUrl) {},
+    onMsgHasRemoteContent(aMsgHdr) {},
+    getSecurityInfo() {},
+    setSecurityInfo(aSecurityInfo) {},
+    getDummyMsgHeader() {},
 
-    QueryInterface: function(aIID) {
-      if (aIID.equals(Components.interfaces.nsIStreamListener) ||
-        aIID.equals(Components.interfaces.nsIMsgHeaderSink) ||
-        aIID.equals(Components.interfaces.nsISupports)) {
-        return this;
-      }
-
-      throw Components.results.NS_NOINTERFACE;
-    }
+    QueryInterface: ChromeUtils.generateQI([
+      "nsIStreamListener",
+      "nsIMsgHeaderSink",
+    ]),
   };
 
   return streamListener;
 }
 
 function getStreamedMessage(msgFolder, msgHeader) {
   return new Promise((resolve, reject) => {
     let msgURI = msgFolder.getUriForMsg(msgHeader);
     var listener = streamListener(() => {
       resolve(listener.mAttachments[0]);
     });
-    let messenger = Components.classes["@mozilla.org/messenger;1"].createInstance(nsIMessenger);
-    let mms = messenger.messageServiceFromURI(msgURI).QueryInterface(nsIMsgMessageService);
+    let messenger = Cc["@mozilla.org/messenger;1"].createInstance(nsIMessenger);
+    let mms = messenger
+      .messageServiceFromURI(msgURI)
+      .QueryInterface(nsIMsgMessageService);
     mms.streamMessage(msgURI, listener, null, null, true, "filter");
   });
 }
 
-function checkHeaders(headerObj, msgHeader, msgAuthor, accountEmail, msgFolder, returnMsgValue, msgHeaders) {
+function checkHeaders(
+  headerObj,
+  msgHeader,
+  msgAuthor,
+  accountEmail,
+  msgFolder,
+  returnMsgValue,
+  msgHeaders
+) {
   return new Promise(async (resolve, reject) => {
-    if (headerObj['autocrypt-setup-message'] && msgHeader.author == msgHeader.recipients) {
-
+    if (
+      headerObj["autocrypt-setup-message"] &&
+      msgHeader.author == msgHeader.recipients
+    ) {
       // To extract Attachement for Autocrypt Setup Message
 
-      returnMsgValue.attachment = await getStreamedMessage(msgFolder, msgHeader);
+      returnMsgValue.attachment = await getStreamedMessage(
+        msgFolder,
+        msgHeader
+      );
 
       if (!returnMsgValue.acSetupMessage) {
         returnMsgValue.value = 1;
         returnMsgValue.acSetupMessage = msgHeader;
-      }
-      else if (returnMsgValue.acSetupMessage.date < msgHeader.date) {
+      } else if (returnMsgValue.acSetupMessage.date < msgHeader.date) {
         returnMsgValue.acSetupMessage = msgHeader;
       }
-
-    }
-    else if (msgAuthor == accountEmail &&
-      ("autocrypt" in headerObj)) {
-
+    } else if (msgAuthor == accountEmail && "autocrypt" in headerObj) {
       let msgType = "Autocrypt";
 
       let fromHeaderExist = null;
       for (let j = 0; j < msgHeaders.length; j++) {
         if (msgHeaders[j].fromAddr == msgAuthor) {
           fromHeaderExist = msgHeaders[j];
           break;
         }
       }
 
       if (fromHeaderExist === null) {
         let dateTime = new Date(0);
         try {
           dateTime = jsmime.headerparser.parseDateHeader(headerObj.date);
-        }
-        catch (x) {}
+        } catch (x) {}
 
         let addHeader = {
           fromAddr: msgAuthor,
-          msgType: msgType,
+          msgType,
           msgData: headerObj.autocrypt,
           date: headerObj.date,
-          dateTime: dateTime
+          dateTime,
         };
         msgHeaders.push(addHeader);
-      }
-      else {
+      } else {
         let dateTime = new Date(0);
         try {
           dateTime = jsmime.headerparser.parseDateHeader(headerObj.date);
-        }
-        catch (x) {}
+        } catch (x) {}
         if (dateTime > fromHeaderExist.dateTime) {
           fromHeaderExist.msgData = headerObj.autocrypt;
           fromHeaderExist.date = headerObj.date;
           fromHeaderExist.msgType = msgType;
           fromHeaderExist.dateTime = dateTime;
         }
       }
     }
 
     resolve({
-      'returnMsgValue': returnMsgValue,
-      'msgHeaders': msgHeaders
+      returnMsgValue,
+      msgHeaders,
     });
   });
 }
 
 function getStreamedHeaders(msgURI, mms) {
-
   return new Promise((resolve, reject) => {
-    let headers = Cc["@mozilla.org/messenger/mimeheaders;1"].createInstance(Ci.nsIMimeHeaders);
+    let headers = Cc["@mozilla.org/messenger/mimeheaders;1"].createInstance(
+      Ci.nsIMimeHeaders
+    );
     let headerObj = {};
     try {
-      mms.streamHeaders(msgURI, EnigmailStreams.newStringStreamListener(aRawString => {
-        try {
-          //EnigmailLog.DEBUG(`getStreamedHeaders: ${aRawString}\n`);
-          headers.initialize(aRawString);
+      mms.streamHeaders(
+        msgURI,
+        EnigmailStreams.newStringStreamListener(aRawString => {
+          try {
+            //EnigmailLog.DEBUG(`getStreamedHeaders: ${aRawString}\n`);
+            headers.initialize(aRawString);
 
-          let i = headers.headerNames;
-          for (let hdr of headers.headerNames) {
-            let hdrName = hdr.toLowerCase();
+            let i = headers.headerNames;
+            for (let hdr of headers.headerNames) {
+              let hdrName = hdr.toLowerCase();
 
-            let hdrValue = headers.extractHeader(hdrName, true);
-            headerObj[hdrName] = hdrValue;
-          }
+              let hdrValue = headers.extractHeader(hdrName, true);
+              headerObj[hdrName] = hdrValue;
+            }
 
-          if ("autocrypt" in headerObj) {
-            let acHeader = headers.extractHeader("autocrypt", false);
-            acHeader = acHeader.replace(/keydata=/i, 'keydata="') + '"';
+            if ("autocrypt" in headerObj) {
+              let acHeader = headers.extractHeader("autocrypt", false);
+              acHeader = acHeader.replace(/keydata=/i, 'keydata="') + '"';
 
-            let paramArr = EnigmailMime.getAllParameters(acHeader);
-            paramArr.keydata = paramArr.keydata.replace(/[\r\n\t ]/g, "");
+              let paramArr = EnigmailMime.getAllParameters(acHeader);
+              paramArr.keydata = paramArr.keydata.replace(/[\r\n\t ]/g, "");
 
-            headerObj.autocrypt = "";
-            for (i in paramArr) {
-              if (headerObj.autocrypt.length > 0) {
-                headerObj.autocrypt += "; ";
+              headerObj.autocrypt = "";
+              for (i in paramArr) {
+                if (headerObj.autocrypt.length > 0) {
+                  headerObj.autocrypt += "; ";
+                }
+                headerObj.autocrypt += `${i}="${paramArr[i]}"`;
               }
-              headerObj.autocrypt += `${i}="${paramArr[i]}"`;
             }
+          } catch (e) {
+            reject({});
+            EnigmailLog.DEBUG(
+              "autoSetup.jsm: getStreamedHeaders: Error: " + e + "\n"
+            );
           }
-        }
-        catch (e) {
-          reject({});
-          EnigmailLog.DEBUG("autoSetup.jsm: getStreamedHeaders: Error: " + e + "\n");
-        }
-        resolve(headerObj);
-      }), null, false);
-    }
-    catch (e) {
+          resolve(headerObj);
+        }),
+        null,
+        false
+      );
+    } catch (e) {
       reject({});
-      EnigmailLog.DEBUG("autoSetup.jsm: getStreamedHeaders: Error: " + e + "\n");
+      EnigmailLog.DEBUG(
+        "autoSetup.jsm: getStreamedHeaders: Error: " + e + "\n"
+      );
     }
   });
 }
 
-
 function getCurrentTime() {
   return new Date().getTime() / 1000;
 }

--- a/mail/extensions/openpgp/content/modules/autocrypt.jsm
+++ b/mail/extensions/openpgp/content/modules/autocrypt.jsm
@@ -6,139 +6,180 @@
 
 /**
  *  Module for dealing with received Autocrypt headers, level 0
  *  See details at https://github.com/mailencrypt/autocrypt
  */
 
 var EXPORTED_SYMBOLS = ["EnigmailAutocrypt"];
 
-const Cr = Components.results;
-
-Components.utils.importGlobalProperties(["crypto"]);
+//Cu.importGlobalProperties(["crypto"]);
 
 const jsmime = ChromeUtils.import("resource:///modules/jsmime.jsm").jsmime;
-const EnigmailCore = ChromeUtils.import("chrome://openpgp/content/modules/core.jsm").EnigmailCore;
-const EnigmailLog = ChromeUtils.import("chrome://openpgp/content/modules/log.jsm").EnigmailLog;
-const EnigmailLocale = ChromeUtils.import("chrome://openpgp/content/modules/locale.jsm").EnigmailLocale;
-const EnigmailFuncs = ChromeUtils.import("chrome://openpgp/content/modules/funcs.jsm").EnigmailFuncs;
-const EnigmailMime = ChromeUtils.import("chrome://openpgp/content/modules/mime.jsm").EnigmailMime;
-const EnigmailSqliteDb = ChromeUtils.import("chrome://openpgp/content/modules/sqliteDb.jsm").EnigmailSqliteDb;
-const PromiseUtils = ChromeUtils.import("resource://gre/modules/PromiseUtils.jsm").PromiseUtils;
-const EnigmailTimer = ChromeUtils.import("chrome://openpgp/content/modules/timer.jsm").EnigmailTimer;
-const EnigmailKey = ChromeUtils.import("chrome://openpgp/content/modules/key.jsm").EnigmailKey;
-const EnigmailKeyRing = ChromeUtils.import("chrome://openpgp/content/modules/keyRing.jsm").EnigmailKeyRing;
-const EnigmailOpenPGP = ChromeUtils.import("chrome://openpgp/content/modules/openpgp.jsm").EnigmailOpenPGP;
-const EnigmailRNG = ChromeUtils.import("chrome://openpgp/content/modules/rng.jsm").EnigmailRNG;
-const EnigmailSend = ChromeUtils.import("chrome://openpgp/content/modules/send.jsm").EnigmailSend;
-const EnigmailStreams = ChromeUtils.import("chrome://openpgp/content/modules/streams.jsm").EnigmailStreams;
-const EnigmailArmor = ChromeUtils.import("chrome://openpgp/content/modules/armor.jsm").EnigmailArmor;
-const EnigmailData = ChromeUtils.import("chrome://openpgp/content/modules/data.jsm").EnigmailData;
-const EnigmailRules = ChromeUtils.import("chrome://openpgp/content/modules/rules.jsm").EnigmailRules;
-const EnigmailStdlib = ChromeUtils.import("chrome://openpgp/content/modules/stdlib.jsm").EnigmailStdlib;
-const EnigmailPrefs = ChromeUtils.import("chrome://openpgp/content/modules/prefs.jsm").EnigmailPrefs;
-const EnigmailConstants = ChromeUtils.import("chrome://openpgp/content/modules/constants.jsm").EnigmailConstants;
-const EnigmailCryptoAPI = ChromeUtils.import("chrome://openpgp/content/modules/cryptoAPI.jsm").EnigmailCryptoAPI;
+const EnigmailLog = ChromeUtils.import(
+  "chrome://openpgp/content/modules/log.jsm"
+).EnigmailLog;
+const EnigmailFuncs = ChromeUtils.import(
+  "chrome://openpgp/content/modules/funcs.jsm"
+).EnigmailFuncs;
+const EnigmailMime = ChromeUtils.import(
+  "chrome://openpgp/content/modules/mime.jsm"
+).EnigmailMime;
+const EnigmailSqliteDb = ChromeUtils.import(
+  "chrome://openpgp/content/modules/sqliteDb.jsm"
+).EnigmailSqliteDb;
+const PromiseUtils = ChromeUtils.import(
+  "resource://gre/modules/PromiseUtils.jsm"
+).PromiseUtils;
+const EnigmailKeyRing = ChromeUtils.import(
+  "chrome://openpgp/content/modules/keyRing.jsm"
+).EnigmailKeyRing;
+const EnigmailStreams = ChromeUtils.import(
+  "chrome://openpgp/content/modules/streams.jsm"
+).EnigmailStreams;
+const EnigmailArmor = ChromeUtils.import(
+  "chrome://openpgp/content/modules/armor.jsm"
+).EnigmailArmor;
+const EnigmailRules = ChromeUtils.import(
+  "chrome://openpgp/content/modules/rules.jsm"
+).EnigmailRules;
+const EnigmailStdlib = ChromeUtils.import(
+  "chrome://openpgp/content/modules/stdlib.jsm"
+).EnigmailStdlib;
+const EnigmailConstants = ChromeUtils.import(
+  "chrome://openpgp/content/modules/constants.jsm"
+).EnigmailConstants;
+const EnigmailCryptoAPI = ChromeUtils.import(
+  "chrome://openpgp/content/modules/cryptoAPI.jsm"
+).EnigmailCryptoAPI;
 
 var gCreatedSetupIds = [];
 
 var EnigmailAutocrypt = {
   /**
    * Process the "Autocrypt:" header and if successful store the update in the database
    *
    * @param {String} fromAddr:               Address of sender (From: header)
    * @param {Array of String} headerDataArr: all instances of the Autocrypt: header found in the message
    * @param {String or Number} dateSent:     "Date:" field of the message as readable string or in seconds after 1970-01-01
    * @param {Boolean} autoCryptEnabled:      if true, autocrypt is enabled for the context of the message
    *
    * @return {Promise<Number>}: success: 0 = success, 1+ = failure
    */
-  processAutocryptHeader: async function(fromAddr, headerDataArr, dateSent, autoCryptEnabled = false, isGossip = false) {
-    EnigmailLog.DEBUG("autocrypt.jsm: processAutocryptHeader(): from=" + fromAddr + "\n");
+  async processAutocryptHeader(
+    fromAddr,
+    headerDataArr,
+    dateSent,
+    autoCryptEnabled = false,
+    isGossip = false
+  ) {
+    EnigmailLog.DEBUG(
+      "autocrypt.jsm: processAutocryptHeader(): from=" + fromAddr + "\n"
+    );
     let conn;
 
     try {
       // critical parameters: {param: mandatory}
       const CRITICAL = {
         addr: true,
         keydata: true,
         type: false, // That's actually oboslete according to the Level 1 spec.
-        "prefer-encrypt": false
+        "prefer-encrypt": false,
       };
 
       try {
         fromAddr = EnigmailFuncs.stripEmail(fromAddr).toLowerCase();
-      }
-      catch (ex) {
+      } catch (ex) {
         throw new Error("processAutocryptHeader error " + ex);
       }
       let foundTypes = {};
       let paramArr = [];
 
       for (let hdrNum = 0; hdrNum < headerDataArr.length; hdrNum++) {
-
         let hdr = headerDataArr[hdrNum].replace(/[\r\n \t]/g, "");
         let k = hdr.search(/keydata=/);
         if (k > 0) {
           let d = hdr.substr(k);
           if (d.search(/"/) < 0) {
             hdr = hdr.replace(/keydata=/, 'keydata="') + '"';
           }
         }
 
         paramArr = EnigmailMime.getAllParameters(hdr);
 
         for (let i in CRITICAL) {
           if (CRITICAL[i]) {
             // found mandatory parameter
             if (!(i in paramArr)) {
-              EnigmailLog.DEBUG("autocrypt.jsm: processAutocryptHeader: cannot find param '" + i + "'\n");
+              EnigmailLog.DEBUG(
+                "autocrypt.jsm: processAutocryptHeader: cannot find param '" +
+                  i +
+                  "'\n"
+              );
               return 1; // do nothing if not all mandatory parts are present
             }
           }
         }
 
         for (let i in paramArr) {
           if (i.substr(0, 1) !== "_") {
             if (!(i in CRITICAL)) {
-              EnigmailLog.DEBUG("autocrypt.jsm: processAutocryptHeader: unknown critical param " + i + "\n");
+              EnigmailLog.DEBUG(
+                "autocrypt.jsm: processAutocryptHeader: unknown critical param " +
+                  i +
+                  "\n"
+              );
               return 2; // do nothing if an unknown critical parameter is found
             }
           }
         }
 
         paramArr.addr = paramArr.addr.toLowerCase();
 
         if (fromAddr !== paramArr.addr) {
-          EnigmailLog.DEBUG("autocrypt.jsm: processAutocryptHeader: from Addr " + fromAddr + " != " + paramArr.addr.toLowerCase() + "\n");
+          EnigmailLog.DEBUG(
+            "autocrypt.jsm: processAutocryptHeader: from Addr " +
+              fromAddr +
+              " != " +
+              paramArr.addr.toLowerCase() +
+              "\n"
+          );
 
           return 3;
         }
 
         if (!("type" in paramArr)) {
-          paramArr.type = (isGossip ? "1g" : "1");
-        }
-        else {
+          paramArr.type = isGossip ? "1g" : "1";
+        } else {
           paramArr.type = paramArr.type.toLowerCase();
           if (paramArr.type !== "1") {
-            EnigmailLog.DEBUG("autocrypt.jsm: processAutocryptHeader: unknown type " + paramArr.type + "\n");
+            EnigmailLog.DEBUG(
+              "autocrypt.jsm: processAutocryptHeader: unknown type " +
+                paramArr.type +
+                "\n"
+            );
             return 4; // we currently only support 1 (=OpenPGP)
           }
         }
 
         try {
-          let keyData = atob(paramArr.keydata);
-        }
-        catch (ex) {
-          EnigmailLog.DEBUG("autocrypt.jsm: processAutocryptHeader: key is not base64-encoded\n");
+          atob(paramArr.keydata); // don't need result
+        } catch (ex) {
+          EnigmailLog.DEBUG(
+            "autocrypt.jsm: processAutocryptHeader: key is not base64-encoded\n"
+          );
           return 5;
         }
 
         if (paramArr.type in foundTypes) {
-          EnigmailLog.DEBUG("autocrypt.jsm: processAutocryptHeader: duplicate header for type=" + paramArr.type + "\n");
+          EnigmailLog.DEBUG(
+            "autocrypt.jsm: processAutocryptHeader: duplicate header for type=" +
+              paramArr.type +
+              "\n"
+          );
           return 6; // do not process anything if more than one Autocrypt header for the same type is found
         }
 
         foundTypes[paramArr.type] = 1;
       }
 
       if (isGossip) {
         paramArr["prefer-encrypt"] = "nopreference";
@@ -146,104 +187,125 @@ var EnigmailAutocrypt = {
 
       if (!("prefer-encrypt" in paramArr)) {
         paramArr["prefer-encrypt"] = "nopreference";
       }
 
       let lastDate;
       if (typeof dateSent === "string") {
         lastDate = jsmime.headerparser.parseDateHeader(dateSent);
-      }
-      else {
+      } else {
         lastDate = new Date(dateSent * 1000);
       }
       let now = new Date();
       if (lastDate > now) {
         lastDate = now;
       }
       paramArr.dateSent = lastDate;
 
-      if (("_enigmail_artificial" in paramArr) && (paramArr._enigmail_artificial === "yes")) {
+      if (
+        "_enigmail_artificial" in paramArr &&
+        paramArr._enigmail_artificial === "yes"
+      ) {
         if ("_enigmail_fpr" in paramArr) {
           paramArr.fpr = paramArr._enigmail_fpr;
         }
 
         paramArr.keydata = "";
         paramArr.autocryptDate = 0;
-      }
-      else {
+      } else {
         paramArr.autocryptDate = lastDate;
       }
 
       try {
         conn = await EnigmailSqliteDb.openDatabase();
-      }
-      catch (ex) {
-        EnigmailLog.DEBUG("autocrypt.jsm: processAutocryptHeader: could not open database\n");
+      } catch (ex) {
+        EnigmailLog.DEBUG(
+          "autocrypt.jsm: processAutocryptHeader: could not open database\n"
+        );
         return 7;
       }
 
       let resultObj = await findUserRecord(conn, [fromAddr], paramArr.type);
       EnigmailLog.DEBUG("autocrypt.jsm: got " + resultObj.numRows + " rows\n");
       if (resultObj.data.length === 0) {
         await appendUser(conn, paramArr);
-      }
-      else {
+      } else {
         await updateUser(conn, paramArr, resultObj.data, autoCryptEnabled);
       }
 
       EnigmailLog.DEBUG("autocrypt.jsm: OK - closing connection\n");
       conn.close();
       return 0;
-    }
-    catch (err) {
-      EnigmailLog.DEBUG("autocrypt.jsm: error - closing connection: " + err + "\n");
+    } catch (err) {
+      EnigmailLog.DEBUG(
+        "autocrypt.jsm: error - closing connection: " + err + "\n"
+      );
       conn.close();
       return 8;
     }
   },
 
   /**
    * Import autocrypt OpenPGP keys into regular keyring for a given list of email addresses
    * @param {Array of String} emailAddr: email addresses
    * @param {Boolean} acceptGossipKeys: import keys received via gossip
    *
    * @return {Promise<Array of keyObj>}
    */
-  importAutocryptKeys: async function(emailAddr, acceptGossipKeys = false) {
+  async importAutocryptKeys(emailAddr, acceptGossipKeys = false) {
     EnigmailLog.DEBUG("autocrypt.jsm: importAutocryptKeys()\n");
 
     let keyArr = await this.getOpenPGPKeyForEmail(emailAddr);
-    if (!keyArr) return [];
+    if (!keyArr) {
+      return [];
+    }
 
     let importedKeys = [];
     let now = new Date();
     let prev = null;
 
     for (let i = 0; i < keyArr.length; i++) {
-      if (prev && prev.email === keyArr[i].email && prev.type === "1" && keyArr[i].type === "1g") {
+      if (
+        prev &&
+        prev.email === keyArr[i].email &&
+        prev.type === "1" &&
+        keyArr[i].type === "1g"
+      ) {
         // skip if we have "gossip" key preceeded by a "regular" key
         continue;
       }
       if (!acceptGossipKeys && keyArr[i].type === "1g") {
-        EnigmailLog.DEBUG(`autocrypt.jsm: importAutocryptKeys: skipping gossip key for ${keyArr[i].email}\n`);
+        EnigmailLog.DEBUG(
+          `autocrypt.jsm: importAutocryptKeys: skipping gossip key for ${
+            keyArr[i].email
+          }\n`
+        );
         continue;
       }
 
       prev = keyArr[i];
       if ((now - keyArr[i].lastAutocrypt) / (1000 * 60 * 60 * 24) < 366) {
         // only import keys received less than 12 months ago
         try {
           let keyData = atob(keyArr[i].keyData);
           if (keyData.length > 1) {
-            importedKeys = await this.applyKeyFromKeydata(keyData, keyArr[i].email, keyArr[i].state, keyArr[i].type);
+            importedKeys = await this.applyKeyFromKeydata(
+              keyData,
+              keyArr[i].email,
+              keyArr[i].state,
+              keyArr[i].type
+            );
           }
-        }
-        catch (ex) {
-          EnigmailLog.DEBUG("autocrypt.jsm importAutocryptKeys: exception " + ex.toString() + "\n");
+        } catch (ex) {
+          EnigmailLog.DEBUG(
+            "autocrypt.jsm importAutocryptKeys: exception " +
+              ex.toString() +
+              "\n"
+          );
         }
       }
     }
 
     return importedKeys;
   },
 
   /**
@@ -251,170 +313,198 @@ var EnigmailAutocrypt = {
    *
    * @param {String} keyData - String key data (BLOB, binary form)
    * @param {String} email - email address associated with key
    * @param {String} autocryptState - mutual or nopreference
    * @param {String} type - autocrypt header type (1 / 1g)
    *
    * @return {Promise<Array of keys>} list of imported keys
    */
-  applyKeyFromKeydata: async function(keyData, email, autocryptState, type) {
+  async applyKeyFromKeydata(keyData, email, autocryptState, type) {
+    throw new Error("Not implemented");
+
+    /*
     let keysObj = {};
     let importedKeys = [];
 
-    let pubkey = EnigmailOpenPGP.enigmailFuncs.bytesToArmor(EnigmailOpenPGP.armor.public_key, keyData);
+    // TODO: need a MPL version of bytesToArmor
+    let pubkey = EnigmailOpenPGP.enigmailFuncs.bytesToArmor(
+      EnigmailOpenPGP.armor.public_key,
+      keyData
+    );
     await EnigmailKeyRing.importKeyAsync(null, false, pubkey, "", {}, keysObj);
 
     if (keysObj.value) {
       importedKeys = importedKeys.concat(keysObj.value);
 
       if (keysObj.value.length > 0) {
         let key = EnigmailKeyRing.getKeyById(keysObj.value[0]);
 
         // enable encryption if state (prefer-encrypt) is "mutual";
         // otherwise, disable it explicitely
-        let signEncrypt = (autocryptState === "mutual" ? 1 : 0);
+        let signEncrypt = autocryptState === "mutual" ? 1 : 0;
 
         if (key && key.fpr) {
           let ruleObj = {
             email: `{${EnigmailConstants.AC_RULE_PREFIX}${email}}`,
             keyList: `0x${key.fpr}`,
             sign: signEncrypt,
             encrypt: signEncrypt,
             pgpMime: 2,
-            flags: 0
+            flags: 0,
           };
 
           EnigmailRules.insertOrUpdateRule(ruleObj);
           await this.setKeyImported(null, email);
         }
       }
     }
 
     return importedKeys;
+    */
   },
 
   /**
    * Update key in the Autocrypt database to mark it "imported in keyring"
    */
-  setKeyImported: async function(connection, email) {
+  async setKeyImported(connection, email) {
     EnigmailLog.DEBUG(`autocrypt.jsm: setKeyImported(${email})\n`);
     try {
       let conn = connection;
       if (!conn) {
         conn = await EnigmailSqliteDb.openDatabase();
       }
-      let updateStr = "update autocrypt_keydata set keyring_inserted = '1' where email = :email;";
+      let updateStr =
+        "update autocrypt_keydata set keyring_inserted = '1' where email = :email;";
 
       let updateObj = {
-        email: email.toLowerCase()
+        email: email.toLowerCase(),
       };
 
       await new Promise((resolve, reject) =>
-        conn.executeTransaction(function _trx() {
-          conn.execute(updateStr, updateObj).then(r => {
-            resolve(r);
-          }).catch(err => {
-            EnigmailLog.DEBUG(`autocrypt.jsm: setKeyImported: error ${err}\n`);
-            reject(err);
-          });
-        }));
+        conn.executeTransaction(function() {
+          conn
+            .execute(updateStr, updateObj)
+            .then(r => {
+              resolve(r);
+            })
+            .catch(err => {
+              EnigmailLog.DEBUG(
+                `autocrypt.jsm: setKeyImported: error ${err}\n`
+              );
+              reject(err);
+            });
+        })
+      );
 
-      if (!connection) conn.close();
-    }
-    catch (err) {
+      if (!connection) {
+        conn.close();
+      }
+    } catch (err) {
       EnigmailLog.DEBUG(`autocrypt.jsm: setKeyImported: error ${err}\n`);
       throw err;
     }
   },
 
   /**
    * Go through all emails in the autocrypt store and determine which keys already
    * have a per-recipient rule
    */
-  updateAllImportedKeys: async function() {
+  async updateAllImportedKeys() {
     EnigmailLog.DEBUG(`autocrypt.jsm: updateAllImportedKeys()\n`);
     try {
       let conn = await EnigmailSqliteDb.openDatabase();
 
       let rows = [];
-      await conn.execute("select email, type from autocrypt_keydata where type = '1';", {},
-        function _onRow(record) {
+      await conn.execute(
+        "select email, type from autocrypt_keydata where type = '1';",
+        {},
+        function(record) {
           rows.push(record.getResultByName("email"));
-        });
+        }
+      );
 
       for (let i in rows) {
-        let r = EnigmailRules.getRuleByEmail(`${EnigmailConstants.AC_RULE_PREFIX}${rows[i]}`);
+        let r = EnigmailRules.getRuleByEmail(
+          `${EnigmailConstants.AC_RULE_PREFIX}${rows[i]}`
+        );
         if (r) {
           await this.setKeyImported(conn, rows[i], "1");
         }
-
       }
       EnigmailLog.DEBUG(`autocrypt.jsm: updateAllImportedKeys done\n`);
 
       conn.close();
-    }
-    catch (err) {
+    } catch (err) {
       EnigmailLog.DEBUG(`autocrypt.jsm: updateAllImportedKeys: error ${err}\n`);
       throw err;
     }
   },
 
   /**
    * Find an autocrypt OpenPGP key for a given list of email addresses
    * @param emailAddr: Array of String - email addresses
    *
    * @return Promise(<Array of Object>)
    *      Object: {fpr, keyData, lastAutocrypt}
    */
-  getOpenPGPKeyForEmail: function(emailAddr) {
-    EnigmailLog.DEBUG("autocrypt.jsm: getOpenPGPKeyForEmail(" + emailAddr.join(",") + ")\n");
+  getOpenPGPKeyForEmail(emailAddr) {
+    EnigmailLog.DEBUG(
+      "autocrypt.jsm: getOpenPGPKeyForEmail(" + emailAddr.join(",") + ")\n"
+    );
 
     let conn;
 
     return new Promise((resolve, reject) => {
-      EnigmailSqliteDb.openDatabase().then(
-        function onConnection(connection) {
-          conn = connection;
-          return findUserRecord(conn, emailAddr, "1,1g");
-        },
-        function onError(error) {
-          EnigmailLog.DEBUG("autocrypt.jsm: getOpenPGPKeyForEmail: could not open database\n");
-          reject("getOpenPGPKeyForEmail1 error " + error);
-        }
-      ).then(
-        function gotData(resultObj) {
-          EnigmailLog.DEBUG("autocrypt.jsm: getOpenPGPKeyForEmail got " + resultObj.numRows + " rows\n");
+      EnigmailSqliteDb.openDatabase()
+        .then(
+          function(connection) {
+            conn = connection;
+            return findUserRecord(conn, emailAddr, "1,1g");
+          },
+          function(error) {
+            EnigmailLog.DEBUG(
+              "autocrypt.jsm: getOpenPGPKeyForEmail: could not open database\n"
+            );
+            reject("getOpenPGPKeyForEmail1 error " + error);
+          }
+        )
+        .then(function(resultObj) {
+          EnigmailLog.DEBUG(
+            "autocrypt.jsm: getOpenPGPKeyForEmail got " +
+              resultObj.numRows +
+              " rows\n"
+          );
           conn.close();
 
           if (resultObj.data.length === 0) {
             resolve(null);
-          }
-          else {
+          } else {
             let retArr = [];
             for (let i in resultObj.data) {
               let record = resultObj.data[i];
               retArr.push({
                 email: record.getResultByName("email"),
                 fpr: record.getResultByName("fpr"),
                 keyData: record.getResultByName("keydata"),
                 state: record.getResultByName("state"),
                 type: record.getResultByName("type"),
-                lastAutocrypt: new Date(record.getResultByName("last_seen_autocrypt"))
+                lastAutocrypt: new Date(
+                  record.getResultByName("last_seen_autocrypt")
+                ),
               });
             }
 
             resolve(retArr);
           }
-        }
-      ).
-      catch((err) => {
-        conn.close();
-        reject("getOpenPGPKeyForEmail: error " + err);
-      });
+        })
+        .catch(err => {
+          conn.close();
+          reject("getOpenPGPKeyForEmail: error " + err);
+        });
     });
   },
 
   /**
    * Create Autocrypt Setup Message
    *
    * @param identity: Object - nsIMsgIdentity
    *
@@ -535,56 +625,63 @@ var EnigmailAutocrypt = {
         else {
           reject(99);
         }
       });
     });
   },
   */
 
-
   /**
    * get the data of the attachment of a setup message
    *
    * @param attachmentUrl: String - URL of the attachment
    *
    * @return Promise(Object):
    *            attachmentData:   String - complete attachment data
    *            passphraseFormat: String - extracted format from the header (e.g. numeric9x4) [optional]
    *            passphraseHint:   String - 1st two digits of the password [optional]
    */
-  getSetupMessageData: function(attachmentUrl) {
+  getSetupMessageData(attachmentUrl) {
     EnigmailLog.DEBUG("autocrypt.jsm: getSetupMessageData()\n");
 
     return new Promise((resolve, reject) => {
       let s = EnigmailStreams.newStringStreamListener(data => {
         let start = {},
           end = {};
-        let msgType = EnigmailArmor.locateArmoredBlock(data, 0, "", start, end, {});
+        let msgType = EnigmailArmor.locateArmoredBlock(
+          data,
+          0,
+          "",
+          start,
+          end,
+          {}
+        );
 
         if (msgType === "MESSAGE") {
-          EnigmailLog.DEBUG("autocrypt.jsm: getSetupMessageData: got backup key\n");
+          EnigmailLog.DEBUG(
+            "autocrypt.jsm: getSetupMessageData: got backup key\n"
+          );
           let armorHdr = EnigmailArmor.getArmorHeaders(data);
 
           let passphraseFormat = "generic";
           if ("passphrase-format" in armorHdr) {
             passphraseFormat = armorHdr["passphrase-format"];
           }
           let passphraseHint = "";
           if ("passphrase-begin" in armorHdr) {
             passphraseHint = armorHdr["passphrase-begin"];
           }
 
           resolve({
             attachmentData: data,
-            passphraseFormat: passphraseFormat,
-            passphraseHint: passphraseHint
+            passphraseFormat,
+            passphraseHint,
           });
-        }
-        else {
+        } else {
           reject("getSetupMessageData");
         }
       });
 
       let channel = EnigmailStreams.createChannel(attachmentUrl);
       channel.asyncOpen(s, null);
     });
   },
@@ -645,82 +742,98 @@ var EnigmailAutocrypt = {
       });
     });
   },
   */
 
   /**
    * Determine if a message id was self-created (only during same TB session)
    */
-  isSelfCreatedSetupMessage: function(messageId) {
-    return (gCreatedSetupIds.indexOf(messageId) >= 0);
+  isSelfCreatedSetupMessage(messageId) {
+    return gCreatedSetupIds.includes(messageId);
   },
 
   /**
    * Check if an account is set up with OpenPGP and if the configured key is valid
    *
    * @param emailAddr: String - email address identifying the account
    *
    * @return Boolean: true: account is valid / false: OpenPGP not configured or key not valid
    */
-  isAccountSetupForPgp: function(emailAddr) {
-    let id = EnigmailStdlib.getIdentityForEmail(EnigmailFuncs.stripEmail(emailAddr).toLowerCase());
+  isAccountSetupForPgp(emailAddr) {
+    let id = EnigmailStdlib.getIdentityForEmail(
+      EnigmailFuncs.stripEmail(emailAddr).toLowerCase()
+    );
     let keyObj = null;
 
-    if (!(id && id.identity)) return false;
-    if (!id.identity.getBoolAttribute("enablePgp")) return false;
+    if (!(id && id.identity)) {
+      return false;
+    }
+    if (!id.identity.getBoolAttribute("enablePgp")) {
+      return false;
+    }
 
     if (id.identity.getIntAttribute("pgpKeyMode") === 1) {
-      keyObj = EnigmailKeyRing.getKeyById(id.identity.getCharAttribute("pgpkeyId"));
-    }
-    else {
+      keyObj = EnigmailKeyRing.getKeyById(
+        id.identity.getCharAttribute("pgpkeyId")
+      );
+    } else {
       keyObj = EnigmailKeyRing.getSecretKeyByUserId(emailAddr);
     }
 
-    if (!keyObj) return false;
-    if (!keyObj.secretAvailable) return false;
+    if (!keyObj) {
+      return false;
+    }
+    if (!keyObj.secretAvailable) {
+      return false;
+    }
 
     let o = keyObj.getEncryptionValidity();
-    if (!o.keyValid) return false;
+    if (!o.keyValid) {
+      return false;
+    }
     o = keyObj.getSigningValidity();
-    if (!o.keyValid) return false;
+    if (!o.keyValid) {
+      return false;
+    }
 
     return true;
   },
 
   /**
    * Delete the record for a user from the autocrypt keystore
    * The record with the highest precedence is deleted (i.e. type=1 before type=1g)
    */
-  deleteUser: async function(email, type) {
+  async deleteUser(email, type) {
     EnigmailLog.DEBUG(`autocrypt.jsm: deleteUser(${email})\n`);
     let conn = await EnigmailSqliteDb.openDatabase();
 
-    let updateStr = "delete from autocrypt_keydata where email = :email and type = :type";
+    let updateStr =
+      "delete from autocrypt_keydata where email = :email and type = :type";
     let updateObj = {
-      email: email,
-      type: type
+      email,
+      type,
     };
 
     await new Promise((resolve, reject) => {
-      conn.executeTransaction(function _trx() {
-        conn.execute(updateStr, updateObj).then(
-          function _ok() {
+      conn.executeTransaction(function() {
+        conn
+          .execute(updateStr, updateObj)
+          .then(function() {
             resolve();
-          }
-        ).catch(function _err() {
-          reject("update failed");
-        });
+          })
+          .catch(function() {
+            reject("update failed");
+          });
       });
     });
     EnigmailLog.DEBUG(" deletion complete\n");
 
     conn.close();
-  }
-
+  },
 };
 
 /**
  * Find the database record for a given email address and type
  *
  * @param connection: Object - SQLite connection
  * @param emails      Array of String - Email addresses to search
  * @param type:       String - types to search (in lowercase), separated by comma
@@ -732,17 +845,17 @@ var EnigmailAutocrypt = {
 async function findUserRecord(connection, emails, type) {
   EnigmailLog.DEBUG("autocrypt.jsm: findUserRecord\n");
 
   let data = [];
   let t = type.split(/[ ,]+/);
 
   let queryParam = {
     e0: emails[0],
-    t0: t[0]
+    t0: t[0],
   };
 
   let numRows = 0;
 
   let search = ":e0";
   for (let i = 1; i < emails.length; i++) {
     search += ", :e" + i;
     queryParam["e" + i] = emails[i].toLowerCase();
@@ -751,31 +864,36 @@ async function findUserRecord(connection
   let typeParam = ":t0";
   for (let i = 1; i < t.length; i++) {
     typeParam += ", :t" + i;
     queryParam["t" + i] = t[i];
   }
 
   try {
     await connection.execute(
-      "select * from autocrypt_keydata where email in (" + search + ") and type in (" + typeParam + ") order by email, type", queryParam,
-      function _onRow(row) {
+      "select * from autocrypt_keydata where email in (" +
+        search +
+        ") and type in (" +
+        typeParam +
+        ") order by email, type",
+      queryParam,
+      function(row) {
         EnigmailLog.DEBUG("autocrypt.jsm: findUserRecord - got row\n");
         data.push(row);
         ++numRows;
-      });
-  }
-  catch (x) {
+      }
+    );
+  } catch (x) {
     EnigmailLog.DEBUG(`autocrypt.jsm: findUserRecord: error ${x}\n`);
     throw x;
   }
 
   return {
-    data: data,
-    numRows: numRows
+    data,
+    numRows,
   };
 }
 
 /**
  * Create new database record for an Autorypt header
  *
  * @param connection: Object - SQLite connection
  * @param paramsArr:  Object - the Autocrypt header parameters
@@ -785,41 +903,44 @@ async function findUserRecord(connection
 async function appendUser(connection, paramsArr) {
   EnigmailLog.DEBUG("autocrypt.jsm: appendUser(" + paramsArr.addr + ")\n");
 
   if (!("fpr" in paramsArr)) {
     await getFprForKey(paramsArr);
   }
 
   return new Promise((resolve, reject) => {
-
     if (paramsArr.autocryptDate == 0) {
       // do not insert record for non-autocrypt mail
       resolve();
       return;
     }
 
-    connection.executeTransaction(function _trx() {
-      connection.execute("insert into autocrypt_keydata (email, keydata, fpr, type, last_seen_autocrypt, last_seen, state) values " +
-        "(:email, :keyData, :fpr, :type, :lastAutocrypt, :lastSeen, :state)", {
-          email: paramsArr.addr.toLowerCase(),
-          keyData: paramsArr.keydata,
-          fpr: ("fpr" in paramsArr ? paramsArr.fpr : ""),
-          type: paramsArr.type,
-          lastAutocrypt: paramsArr.dateSent.toJSON(),
-          lastSeen: paramsArr.dateSent.toJSON(),
-          state: paramsArr["prefer-encrypt"]
-        }).then(
-        function _ok() {
+    connection.executeTransaction(function() {
+      connection
+        .execute(
+          "insert into autocrypt_keydata (email, keydata, fpr, type, last_seen_autocrypt, last_seen, state) values " +
+            "(:email, :keyData, :fpr, :type, :lastAutocrypt, :lastSeen, :state)",
+          {
+            email: paramsArr.addr.toLowerCase(),
+            keyData: paramsArr.keydata,
+            fpr: "fpr" in paramsArr ? paramsArr.fpr : "",
+            type: paramsArr.type,
+            lastAutocrypt: paramsArr.dateSent.toJSON(),
+            lastSeen: paramsArr.dateSent.toJSON(),
+            state: paramsArr["prefer-encrypt"],
+          }
+        )
+        .then(function() {
           EnigmailLog.DEBUG("autocrypt.jsm: appendUser - OK\n");
           resolve();
-        }
-      ).catch(function _err() {
-        reject("appendUser");
-      });
+        })
+        .catch(function() {
+          reject("appendUser");
+        });
     });
   });
 }
 
 /**
  * Update the record for an email address and type, if the email we got is newer
  * than the latest record we already stored
  *
@@ -829,121 +950,142 @@ async function appendUser(connection, pa
  * @param autoCryptEnabled: Boolean: is autocrypt enabled for this transaction
  *
  * @return Promise
  */
 async function updateUser(connection, paramsArr, resultRows, autoCryptEnabled) {
   EnigmailLog.DEBUG("autocrypt.jsm: updateUser\n");
 
   let currData = resultRows[0];
-  let deferred = PromiseUtils.defer();
+  PromiseUtils.defer();
 
   let lastSeen = new Date(currData.getResultByName("last_seen"));
   let lastAutocrypt = new Date(currData.getResultByName("last_seen_autocrypt"));
-  let notGossip = (currData.getResultByName("state") !== "gossip");
+  let notGossip = currData.getResultByName("state") !== "gossip";
   let currentKeyData = currData.getResultByName("keydata");
-  let isKeyInKeyring = (currData.getResultByName("keyring_inserted") === "1");
+  let isKeyInKeyring = currData.getResultByName("keyring_inserted") === "1";
 
-  if (lastSeen >= paramsArr.dateSent ||
-    (paramsArr["prefer-encrypt"] === "gossip" && notGossip)) {
-    EnigmailLog.DEBUG("autocrypt.jsm: updateUser: not a relevant new latest message\n");
+  if (
+    lastSeen >= paramsArr.dateSent ||
+    (paramsArr["prefer-encrypt"] === "gossip" && notGossip)
+  ) {
+    EnigmailLog.DEBUG(
+      "autocrypt.jsm: updateUser: not a relevant new latest message\n"
+    );
 
     return;
   }
 
   EnigmailLog.DEBUG("autocrypt.jsm: updateUser: updating latest message\n");
 
   let updateStr;
   let updateObj;
 
   if (paramsArr.autocryptDate > 0) {
     lastAutocrypt = paramsArr.autocryptDate;
     if (!("fpr" in paramsArr)) {
       await getFprForKey(paramsArr);
     }
 
-    updateStr = "update autocrypt_keydata set state = :state, keydata = :keyData, last_seen_autocrypt = :lastAutocrypt, " +
+    updateStr =
+      "update autocrypt_keydata set state = :state, keydata = :keyData, last_seen_autocrypt = :lastAutocrypt, " +
       "fpr = :fpr, last_seen = :lastSeen where email = :email and type = :type";
     updateObj = {
       email: paramsArr.addr.toLowerCase(),
       state: paramsArr["prefer-encrypt"],
       keyData: paramsArr.keydata,
-      fpr: ("fpr" in paramsArr ? paramsArr.fpr : ""),
+      fpr: "fpr" in paramsArr ? paramsArr.fpr : "",
       type: paramsArr.type,
       lastAutocrypt: lastAutocrypt.toJSON(),
-      lastSeen: paramsArr.dateSent.toJSON()
+      lastSeen: paramsArr.dateSent.toJSON(),
     };
-  }
-  else {
-    updateStr = "update autocrypt_keydata set state = :state, last_seen = :lastSeen where email = :email and type = :type";
+  } else {
+    updateStr =
+      "update autocrypt_keydata set state = :state, last_seen = :lastSeen where email = :email and type = :type";
     updateObj = {
       email: paramsArr.addr.toLowerCase(),
       state: paramsArr["prefer-encrypt"],
       type: paramsArr.type,
-      lastSeen: paramsArr.dateSent.toJSON()
+      lastSeen: paramsArr.dateSent.toJSON(),
     };
   }
 
   if (!("fpr" in paramsArr)) {
     await getFprForKey(paramsArr);
   }
 
   await new Promise((resolve, reject) => {
-    connection.executeTransaction(function _trx() {
-      connection.execute(updateStr, updateObj).then(
-        function _ok() {
+    connection.executeTransaction(function() {
+      connection
+        .execute(updateStr, updateObj)
+        .then(function() {
           resolve();
-        }
-      ).catch(function _err() {
-        reject("update failed");
-      });
+        })
+        .catch(function() {
+          reject("update failed");
+        });
     });
   });
 
-  if (autoCryptEnabled && isKeyInKeyring && (currentKeyData !== paramsArr.keydata)) {
-    await updateKeyIfNeeded(paramsArr.addr.toLowerCase(), paramsArr.keydata, paramsArr.fpr, paramsArr.type, paramsArr["prefer-encrypt"]);
+  if (
+    autoCryptEnabled &&
+    isKeyInKeyring &&
+    currentKeyData !== paramsArr.keydata
+  ) {
+    await updateKeyIfNeeded(
+      paramsArr.addr.toLowerCase(),
+      paramsArr.keydata,
+      paramsArr.fpr,
+      paramsArr.type,
+      paramsArr["prefer-encrypt"]
+    );
   }
-
-  return;
 }
 
-
 /**
  * Determine if a key in the keyring should be replaced by a new (or updated) key
  * @param {String} email - Email address
  * @param {String} keydata - new keydata to import
  * @param {String} fpr - fingerprint of new key
  * @param {String} keyType - key type (1 / 1g)
  * @param {String} autocryptState - mutual or nopreference
  *
  * @return {Promise<Boolean>} - key updated
  */
 async function updateKeyIfNeeded(email, keydata, fpr, keyType, autocryptState) {
-  let ruleNode = EnigmailRules.getRuleByEmail(EnigmailConstants.AC_RULE_PREFIX + email);
-  if (!ruleNode) return false;
+  let ruleNode = EnigmailRules.getRuleByEmail(
+    EnigmailConstants.AC_RULE_PREFIX + email
+  );
+  if (!ruleNode) {
+    return false;
+  }
 
   let doImport = false;
 
   let currentKeyId = ruleNode.getAttribute("keyList");
   if (`0x${fpr}` === currentKeyId || keyType === "1") {
     doImport = true;
-  }
-  else {
+  } else {
     // Gossip keys
     let keyObj = EnigmailKeyRing.getKeyById(currentKeyId);
     let encOk = keyObj.getEncryptionValidity().keyValid;
 
     if (!encOk) {
       // current key is not valid anymore
       doImport = true;
     }
   }
 
   if (doImport) {
-    await EnigmailAutocrypt.applyKeyFromKeydata(atob(keydata), email, autocryptState, keyType);
+    await EnigmailAutocrypt.applyKeyFromKeydata(
+      atob(keydata),
+      email,
+      autocryptState,
+      keyType
+    );
   }
 
   return doImport;
 }
 
 /**
  * Set the fpr attribute for a given key parameter object
  */
@@ -960,117 +1102,144 @@ async function getFprForKey(paramsArr) {
 
     for (let k in keyInfo) {
       keyArr.push(keyInfo[k]);
     }
 
     if (keyArr.length === 1) {
       paramsArr.fpr = keyArr[0].fpr;
     }
-  }
-  catch (x) {}
+  } catch (x) {}
 }
 
-
 /**
  * Create the 9x4 digits backup code as defined in the Autocrypt spec
  *
  * @return String: xxxx-xxxx-...
  */
-
+/*
 function createBackupCode() {
   let bkpCode = "";
 
   for (let i = 0; i < 9; i++) {
-    if (i > 0) bkpCode += "-";
+    if (i > 0) {
+      bkpCode += "-";
+    }
 
     let a = new Uint8Array(4);
     crypto.getRandomValues(a);
     for (let j = 0; j < 4; j++) {
       bkpCode += String(a[j] % 10);
     }
   }
   return bkpCode;
 }
 
-
 function createBackupOuterMsg(toEmail, encryptedMsg) {
-
   let boundary = EnigmailMime.createBoundary();
 
-  let msgStr = 'To: ' + toEmail + '\r\n' +
-    'From: ' + toEmail + '\r\n' +
-    'Autocrypt-Setup-Message: v1\r\n' +
-    'Subject: ' + EnigmailLocale.getString("autocrypt.setupMsg.subject") + '\r\n' +
-    'Content-type: multipart/mixed; boundary="' + boundary + '"\r\n\r\n' +
-    '--' + boundary + '\r\n' +
-    'Content-Type: text/plain\r\n\r\n' +
-    EnigmailLocale.getString("autocryptSetupReq.setupMsg.desc") + '\r\n\r\n' +
-    EnigmailLocale.getString("autocrypt.setupMsg.msgBody") + '\r\n\r\n' +
-    EnigmailLocale.getString("autocryptSetupReq.setupMsg.backup") + '\r\n' +
-    '--' + boundary + '\r\n' +
-    'Content-Type: application/autocrypt-setup\r\n' +
+  let msgStr =
+    "To: " +
+    toEmail +
+    "\r\n" +
+    "From: " +
+    toEmail +
+    "\r\n" +
+    "Autocrypt-Setup-Message: v1\r\n" +
+    "Subject: " +
+    EnigmailLocale.getString("autocrypt.setupMsg.subject") +
+    "\r\n" +
+    'Content-type: multipart/mixed; boundary="' +
+    boundary +
+    '"\r\n\r\n' +
+    "--" +
+    boundary +
+    "\r\n" +
+    "Content-Type: text/plain\r\n\r\n" +
+    EnigmailLocale.getString("autocryptSetupReq.setupMsg.desc") +
+    "\r\n\r\n" +
+    EnigmailLocale.getString("autocrypt.setupMsg.msgBody") +
+    "\r\n\r\n" +
+    EnigmailLocale.getString("autocryptSetupReq.setupMsg.backup") +
+    "\r\n" +
+    "--" +
+    boundary +
+    "\r\n" +
+    "Content-Type: application/autocrypt-setup\r\n" +
     'Content-Disposition: attachment; filename="autocrypt-setup-message.html"\r\n\r\n' +
-    '<html><body>\r\n' +
-    '<p>' + EnigmailLocale.getString("autocrypt.setupMsg.fileTxt") + '</p>\r\n' +
-    '<pre>\r\n' +
+    "<html><body>\r\n" +
+    "<p>" +
+    EnigmailLocale.getString("autocrypt.setupMsg.fileTxt") +
+    "</p>\r\n" +
+    "<pre>\r\n" +
     encryptedMsg +
-    '</pre></body></html>\r\n' +
-    '--' + boundary + '--\r\n';
+    "</pre></body></html>\r\n" +
+    "--" +
+    boundary +
+    "--\r\n";
 
   return msgStr;
 }
-
+*/
 
 /**
  * @return Object:
  *          fpr:           String - FPR of the imported key
  *          preferEncrypt: String - Autocrypt preferEncrypt value (e.g. mutual)
  */
+/*
 function importSetupKey(keyData) {
-
   EnigmailLog.DEBUG("autocrypt.jsm: importSetupKey()\n");
 
   let preferEncrypt = "nopreference"; // Autocrypt default according spec
   let start = {},
     end = {},
     keyObj = {};
 
-  let msgType = EnigmailArmor.locateArmoredBlock(keyData, 0, "", start, end, {});
+  let msgType = EnigmailArmor.locateArmoredBlock(
+    keyData,
+    0,
+    "",
+    start,
+    end,
+    {}
+  );
   if (msgType === "PRIVATE KEY BLOCK") {
-
     let headers = EnigmailArmor.getArmorHeaders(keyData);
     if ("autocrypt-prefer-encrypt" in headers) {
       preferEncrypt = headers["autocrypt-prefer-encrypt"];
     }
 
     let r = EnigmailKeyRing.importKey(null, false, keyData, "", {}, keyObj);
 
     if (r === 0 && keyObj.value && keyObj.value.length > 0) {
       return {
         fpr: keyObj.value[0],
-        preferEncrypt: preferEncrypt
+        preferEncrypt,
       };
     }
   }
 
   return null;
 }
 
-
 function updateRuleForEmail(email, preferEncrypt, fpr = null) {
-  let node = EnigmailRules.getRuleByEmail(EnigmailConstants.AC_RULE_PREFIX + email);
+  let node = EnigmailRules.getRuleByEmail(
+    EnigmailConstants.AC_RULE_PREFIX + email
+  );
 
   if (node) {
-    let signEncrypt = (preferEncrypt === "mutual" ? "1" : "0");
+    let signEncrypt = preferEncrypt === "mutual" ? "1" : "0";
 
-    if (node.getAttribute("sign") !== signEncrypt ||
-      node.getAttribute("encrypt") !== signEncrypt) {
-
+    if (
+      node.getAttribute("sign") !== signEncrypt ||
+      node.getAttribute("encrypt") !== signEncrypt
+    ) {
       node.setAttribute("sign", signEncrypt);
       node.setAttribute("encrypt", signEncrypt);
       if (fpr) {
         node.setAttribute("keyList", `0x${fpr}`);
       }
       EnigmailRules.saveRulesFile();
     }
   }
 }
+*/

--- a/mail/extensions/openpgp/content/modules/clipboard.jsm
+++ b/mail/extensions/openpgp/content/modules/clipboard.jsm
@@ -5,102 +5,104 @@
  */
 
 "use strict";
 
 var EXPORTED_SYMBOLS = ["EnigmailClipboard"];
 
 // Import the Services module for future use, if we're not in
 // a browser window where it's already loaded.
-const Services = ChromeUtils.import('resource://gre/modules/Services.jsm').Services;
-
-
-// Create a constructor for the built-in supports-string class.
-const nsSupportsString = Components.Constructor("@mozilla.org/supports-string;1", "nsISupportsString");
-
-function SupportsString(str) {
-  // Create an instance of the supports-string class
-  var res = nsSupportsString();
-
-  // Store the JavaScript string that we want to wrap in the new nsISupportsString object
-  res.data = str;
-  return res;
-}
+const Services = ChromeUtils.import("resource://gre/modules/Services.jsm")
+  .Services;
 
 // Create a constructor for the built-in transferable class
-const nsTransferable = Components.Constructor("@mozilla.org/widget/transferable;1", "nsITransferable");
+const nsTransferable = Components.Constructor(
+  "@mozilla.org/widget/transferable;1",
+  "nsITransferable"
+);
 
 // Create a wrapper to construct an nsITransferable instance and set its source to the given window, when necessary
 function Transferable(source) {
   let res = nsTransferable();
-  if ('init' in res) {
+  if ("init" in res) {
     // When passed a Window object, find a suitable privacy context for it.
-    if (source instanceof Ci.nsIDOMWindow)
-      source = source.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIWebNavigation);
+    if (source instanceof Ci.nsIDOMWindow) {
+      source = source
+        .QueryInterface(Ci.nsIInterfaceRequestor)
+        .getInterface(Ci.nsIWebNavigation);
+    }
 
     res.init(source);
   }
   return res;
 }
 
 var EnigmailClipboard = {
-
   /**
    * Get the content string of a clipboard
    *
    * @param window       : nsIWindow or nsIDOMWindow of caller
    * @param clipBoardType: Number - clipboard type according to nsIClipboard
    *
    * @return String - content of clipBoard
    */
 
-  getClipboardContent: function(window, clipBoardType) {
+  getClipboardContent(window, clipBoardType) {
     if (!window) {
       throw new Error("window is a required parameter");
     }
 
-    let clipBoard = Cc["@mozilla.org/widget/clipboard;1"].getService(Ci.nsIClipboard);
+    let clipBoard = Services.clipboard;
     let data = {};
     let cBoardContent = "";
 
-    if (clipBoardType !== clipBoard.kSelectionClipboard || clipBoard.supportsSelectionClipboard()) {
+    if (
+      clipBoardType !== clipBoard.kSelectionClipboard ||
+      clipBoard.supportsSelectionClipboard()
+    ) {
       try {
         let transferable = Transferable(window);
         transferable.addDataFlavor("text/unicode");
         clipBoard.getData(transferable, clipBoardType);
         let flavour = {};
         transferable.getAnyTransferData(flavour, data);
         cBoardContent = data.value.QueryInterface(Ci.nsISupportsString).data;
-      }
-      catch (ex) {}
+      } catch (ex) {}
     }
     return cBoardContent;
   },
 
   /**
    * Set the global (and if available, the selection clipboard)
    *
    * @param str: String - data to set
    * @param clipBoardType: Number - clipboard type according to nsIClipboard.
    *             If not provided, the global plus the selection clipboard will be used
    *
    * @return Boolean: true - success / false - failure
    */
-  setClipboardContent: function(str, clipBoardType) {
+  setClipboardContent(str, clipBoardType) {
     let useClipboard = clipBoardType;
     if (clipBoardType === undefined) {
       useClipboard = Ci.nsIClipboard.kGlobalClipboard;
     }
     try {
-      let clipBoard = Cc["@mozilla.org/widget/clipboard;1"].getService(Ci.nsIClipboard);
-      let clipBoardHlp = Cc["@mozilla.org/widget/clipboardhelper;1"].getService(Ci.nsIClipboardHelper);
+      let clipBoard = Services.clipboard;
+      let clipBoardHlp = Cc["@mozilla.org/widget/clipboardhelper;1"].getService(
+        Ci.nsIClipboardHelper
+      );
       clipBoardHlp.copyStringToClipboard(str, useClipboard);
-      if (clipBoard.supportsSelectionClipboard() &&
-        (useClipboard === Ci.nsIClipboard.kSelectionClipboard || clipBoardType === undefined)) {
-        clipBoardHlp.copyStringToClipboard(str, Ci.nsIClipboard.kSelectionClipboard);
+      if (
+        clipBoard.supportsSelectionClipboard() &&
+        (useClipboard === Ci.nsIClipboard.kSelectionClipboard ||
+          clipBoardType === undefined)
+      ) {
+        clipBoardHlp.copyStringToClipboard(
+          str,
+          Ci.nsIClipboard.kSelectionClipboard
+        );
       }
-    }
-    catch (ex) {
+    } catch (ex) {
       return false;
     }
     return true;
-  }
+  },
 };

--- a/mail/extensions/openpgp/content/modules/commandLine.jsm
+++ b/mail/extensions/openpgp/content/modules/commandLine.jsm
@@ -1,47 +1,60 @@
 /*
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-
 "use strict";
 
 var EXPORTED_SYMBOLS = ["EnigmailCommandLine"];
 
-const EnigmailCompat = ChromeUtils.import("chrome://openpgp/content/modules/compat.jsm").EnigmailCompat;
+const Services = ChromeUtils.import("resource://gre/modules/Services.jsm")
+  .Services;
+const EnigmailCompat = ChromeUtils.import(
+  "chrome://openpgp/content/modules/compat.jsm"
+).EnigmailCompat;
 
-const NS_ENIGCLINE_SERVICE_CID = Components.ID("{847b3ab1-7ab1-11d4-8f02-006008948af5}");
+const NS_ENIGCLINE_SERVICE_CID = Components.ID(
+  "{847b3ab1-7ab1-11d4-8f02-006008948af5}"
+);
 const NS_CLINE_SERVICE_CONTRACTID = "@mozilla.org/enigmail/cline-handler;1";
 
 function Handler() {}
 
 Handler.prototype = {
   classDescription: "Enigmail Key Management CommandLine Service",
   classID: NS_ENIGCLINE_SERVICE_CID,
   contractID: NS_CLINE_SERVICE_CONTRACTID,
-  QueryInterface: EnigmailCompat.generateQI(["nsICommandLineHandler", "nsIFactory"]),
+  QueryInterface: EnigmailCompat.generateQI([
+    "nsICommandLineHandler",
+    "nsIFactory",
+  ]),
 
   // nsICommandLineHandler
-  handle: function(cmdLine) {
+  handle(cmdLine) {
     if (cmdLine.handleFlag("pgpkeyman", false)) {
       cmdLine.preventDefault = true; // do not open main app window
 
-      const wwatch = Cc["@mozilla.org/embedcomp/window-watcher;1"].getService(Ci.nsIWindowWatcher);
-      wwatch.openWindow(null, "chrome://openpgp/content/ui/enigmailKeyManager.xhtml", "_blank", "chrome,dialog=no,all", cmdLine);
+      Services.ww.openWindow(
+        null,
+        "chrome://openpgp/content/ui/enigmailKeyManager.xhtml",
+        "_blank",
+        "chrome,dialog=no,all",
+        cmdLine
+      );
     }
   },
 
   helpInfo: "  -pgpkeyman         Open the OpenPGP key management.\n",
 
-  lockFactory: function(lock) {}
+  lockFactory(lock) {},
 };
 
 var EnigmailCommandLine = {
-  Handler: Handler,
+  Handler,
   categoryRegistry: {
     category: "command-line-handler",
     entry: "m-cline-enigmail",
-    serviceName: NS_CLINE_SERVICE_CONTRACTID
-  }
+    serviceName: NS_CLINE_SERVICE_CONTRACTID,
+  },
 };

--- a/mail/extensions/openpgp/content/modules/compat.jsm
+++ b/mail/extensions/openpgp/content/modules/compat.jsm
@@ -5,99 +5,113 @@
 "use strict";
 
 /**
  *  compatibility Module
  */
 
 var EXPORTED_SYMBOLS = ["EnigmailCompat"];
 
-const XPCOM_APPINFO = "@mozilla.org/xre/app-info;1";
-
 var MailUtils;
 
 MailUtils = ChromeUtils.import("resource:///modules/MailUtils.jsm").MailUtils;
 
-var gCompFields, gPgpMimeObj;
-
 var EnigmailCompat = {
-  generateQI: function(aCid) {
+  generateQI(aCid) {
     return ChromeUtils.generateQI(aCid);
   },
 
-  getExistingFolder: function(folderUri) {
+  getExistingFolder(folderUri) {
     return MailUtils.getExistingFolder(folderUri);
   },
 
   /**
    * Get a mail URL from a uriSpec
    *
    * @param uriSpec: String - URI of the desired message
    *
    * @return Object: nsIURL or nsIMsgMailNewsUrl object
    */
-  getUrlFromUriSpec: function(uriSpec) {
+  getUrlFromUriSpec(uriSpec) {
     try {
-      if (!uriSpec)
+      if (!uriSpec) {
         return null;
+      }
 
-      let messenger = Cc["@mozilla.org/messenger;1"].getService(Ci.nsIMessenger);
+      let messenger = Cc["@mozilla.org/messenger;1"].getService(
+        Ci.nsIMessenger
+      );
       let msgService = messenger.messageServiceFromURI(uriSpec);
 
       let url;
       // TB
       let urlObj = {};
       msgService.GetUrlForUri(uriSpec, urlObj, null);
 
       url = urlObj.value;
 
       if (url.scheme == "file") {
         return url;
       }
-      else {
-        return url.QueryInterface(Ci.nsIMsgMailNewsUrl);
-      }
 
-    }
-    catch (ex) {
+      return url.QueryInterface(Ci.nsIMsgMailNewsUrl);
+    } catch (ex) {
       return null;
     }
   },
   /**
    * Copy a file to a mail folder.
    *   in nsIFile aFile,
    *   in nsIMsgFolder dstFolder,
    *   in unsigned long aMsgFlags,
    *   in ACString aMsgKeywords,
    *   in nsIMsgCopyServiceListener listener,
    *   in nsIMsgWindow msgWindow
    */
-  copyFileToMailFolder: function(file, destFolder, msgFlags, msgKeywords, listener, msgWindow) {
-    let copySvc = Cc["@mozilla.org/messenger/messagecopyservice;1"].getService(Ci.nsIMsgCopyService);
+  copyFileToMailFolder(
+    file,
+    destFolder,
+    msgFlags,
+    msgKeywords,
+    listener,
+    msgWindow
+  ) {
+    let copySvc = Cc["@mozilla.org/messenger/messagecopyservice;1"].getService(
+      Ci.nsIMsgCopyService
+    );
 
-    return copySvc.CopyFileMessage(file, destFolder, null, false, msgFlags, msgKeywords, listener, msgWindow);
+    return copySvc.CopyFileMessage(
+      file,
+      destFolder,
+      null,
+      false,
+      msgFlags,
+      msgKeywords,
+      listener,
+      msgWindow
+    );
   },
 
   /**
    * Get functions that wrap the changes on nsITreeView between TB 60 and TB 68
    *
    * @param treeObj
    * @param listViewHolder
    *
    * @return {Object}
    */
-  getTreeCompatibleFuncs: function(treeObj, listViewHolder) {
+  getTreeCompatibleFuncs(treeObj, listViewHolder) {
     return {
-      getCellAt: function(x,y) {
+      getCellAt(x, y) {
         return treeObj.getCellAt(x, y);
       },
-      rowCountChanged: function(a, b) {
+      rowCountChanged(a, b) {
         return treeObj.rowCountChanged(a, b);
       },
-      invalidate: function() {
+      invalidate() {
         return treeObj.invalidate();
       },
-      invalidateRow: function(r) {
+      invalidateRow(r) {
         return treeObj.invalidateRow(r);
-      }
+      },
     };
   },
 };

--- a/mail/extensions/openpgp/content/modules/configBackup.jsm
+++ b/mail/extensions/openpgp/content/modules/configBackup.jsm
@@ -1,99 +1,106 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-
 "use strict";
 
 var EXPORTED_SYMBOLS = ["EnigmailConfigBackup"];
 
-
-
-
-
-const EnigmailLog = ChromeUtils.import("chrome://openpgp/content/modules/log.jsm").EnigmailLog;
-const EnigmailRules = ChromeUtils.import("chrome://openpgp/content/modules/rules.jsm").EnigmailRules;
-const EnigmailFiles = ChromeUtils.import("chrome://openpgp/content/modules/files.jsm").EnigmailFiles;
-const EnigmailPrefs = ChromeUtils.import("chrome://openpgp/content/modules/prefs.jsm").EnigmailPrefs;
+const EnigmailLog = ChromeUtils.import(
+  "chrome://openpgp/content/modules/log.jsm"
+).EnigmailLog;
+const EnigmailRules = ChromeUtils.import(
+  "chrome://openpgp/content/modules/rules.jsm"
+).EnigmailRules;
+const EnigmailFiles = ChromeUtils.import(
+  "chrome://openpgp/content/modules/files.jsm"
+).EnigmailFiles;
+const EnigmailPrefs = ChromeUtils.import(
+  "chrome://openpgp/content/modules/prefs.jsm"
+).EnigmailPrefs;
 
 const TYPE_BOOL = 1;
 const TYPE_CHAR = 2;
 const TYPE_INT = 3;
 
 const IdentityPref = {
   enablePgp: TYPE_BOOL,
   pgpkeyId: TYPE_CHAR,
   pgpKeyMode: TYPE_INT,
   pgpSignPlain: TYPE_BOOL,
   pgpSignEncrypted: TYPE_BOOL,
   defaultSigningPolicy: TYPE_INT,
   defaultEncryptionPolicy: TYPE_INT,
   openPgpUrlName: TYPE_CHAR,
   pgpMimeMode: TYPE_BOOL,
   attachPgpKey: TYPE_BOOL,
-  autoEncryptDrafts: TYPE_BOOL
+  autoEncryptDrafts: TYPE_BOOL,
 };
 
 var EnigmailConfigBackup = {
-
-  getAccountManager: function() {
-    let amService = Cc["@mozilla.org/messenger/account-manager;1"].getService(Ci.nsIMsgAccountManager);
+  getAccountManager() {
+    let amService = Cc["@mozilla.org/messenger/account-manager;1"].getService(
+      Ci.nsIMsgAccountManager
+    );
     return amService;
   },
 
   /**
    * itereate over all identities and execute a callback function for each found element
    *
    * @param callbackFunc  function  - the callback for each identity
    *                  The function takes the identity as 1st argument, i.e.
    *                    callbackFunc(nsIMsgIdentity)
    * @return  - undefined
    */
-  forAllIdentitites: function(callbackFunc) {
-
+  forAllIdentitites(callbackFunc) {
     let amService = this.getAccountManager();
 
     amService.LoadAccounts(); // ensure accounts are really loaded
     let a = amService.allIdentities;
     for (let i = 0; i < a.length; i++) {
       let id = a.queryElementAt(i, Ci.nsIMsgIdentity);
       try {
         callbackFunc(id);
-      }
-      catch (ex) {
-        EnigmailLog.DEBUG("configBackup.jsm: forAllIdentitites: exception " + ex.toString() + "\n");
+      } catch (ex) {
+        EnigmailLog.DEBUG(
+          "configBackup.jsm: forAllIdentitites: exception " +
+            ex.toString() +
+            "\n"
+        );
       }
     }
   },
 
   /**
    * backup Enigmail preferences to a file
    *
    * @param outputFile  nsIFile - handle to file to be saved
    *
    * @return 0: success, other values: failure
    */
-  backupPrefs: function(outputFile) {
+  backupPrefs(outputFile) {
     EnigmailLog.DEBUG("configBackup.jsm: backupPrefs\n");
 
     // user preference
     let prefObj = {
       enigmailPrefs: EnigmailPrefs.getAllPrefs(),
-      mailIdentities: {}
+      mailIdentities: {},
     };
 
     function getIdentityPrefs(identity) {
-
-      if (!identity.getBoolAttribute("enablePgp")) return; // do nothing if Enigmail disabled
+      if (!identity.getBoolAttribute("enablePgp")) {
+        return;
+      } // do nothing if Enigmail disabled
 
       let keyObj = {
         emailAddress: identity.email.toLowerCase(),
-        identityName: identity.identityName
+        identityName: identity.identityName,
       };
 
       for (let pref in IdentityPref) {
         switch (IdentityPref[pref]) {
           case TYPE_BOOL:
             keyObj[pref] = identity.getBoolAttribute(pref);
             break;
           case TYPE_INT:
@@ -131,28 +138,35 @@ var EnigmailConfigBackup = {
    *
    * @param inputFile  nsIFile - handle to file to be saved
    *
    * @return Object: {
    *     retVal:       Number - 0: success, other values: failure
    *     unmatchedIds: Array (String): keys of identities
    *   }
    */
-  restorePrefs: function(inputFile) {
+  restorePrefs(inputFile) {
     EnigmailLog.DEBUG("configBackup.jsm: restorePrefs\n");
     var prefObj;
     var returnObj = {
       retVal: -1,
-      unmatchedIds: []
+      unmatchedIds: [],
     };
 
     function setIdentityPref(identity) {
       for (let k in prefObj.mailIdentities) {
-        if (prefObj.mailIdentities[k].emailAddress === identity.email.toLowerCase()) {
-          EnigmailLog.DEBUG("configBackup.jsm: setIdentityPref: restoring values for " + identity.email + "\n");
+        if (
+          prefObj.mailIdentities[k].emailAddress ===
+          identity.email.toLowerCase()
+        ) {
+          EnigmailLog.DEBUG(
+            "configBackup.jsm: setIdentityPref: restoring values for " +
+              identity.email +
+              "\n"
+          );
           prefObj.mailIdentities[k].foundMatchingEmail = true;
           let keyObj = prefObj.mailIdentities[k];
           for (let pref in IdentityPref) {
             switch (IdentityPref[pref]) {
               case TYPE_BOOL:
                 identity.setBoolAttribute(pref, keyObj[pref]);
                 break;
               case TYPE_INT:
@@ -162,27 +176,28 @@ var EnigmailConfigBackup = {
                 identity.setCharAttribute(pref, keyObj[pref]);
                 break;
             }
           }
           return;
         }
       }
 
-      EnigmailLog.DEBUG("configBackup.jsm: setIdentityPref: no matching data for " + identity.email + "\n");
+      EnigmailLog.DEBUG(
+        "configBackup.jsm: setIdentityPref: no matching data for " +
+          identity.email +
+          "\n"
+      );
     }
 
     // Profile must be a single UTF-8 encoded JSON object.
     try {
       let jsonStr = EnigmailFiles.readFile(inputFile);
       prefObj = JSON.parse(jsonStr);
 
-      var nsIPB = Ci.nsIPrefBranch;
-      var branch = EnigmailPrefs.getPrefBranch();
-
       // Set all options recorded in the JSON file.
       for (let name in prefObj.enigmailPrefs) {
         EnigmailPrefs.setPref(name, prefObj.enigmailPrefs[name]);
       }
 
       this.forAllIdentitites(setIdentityPref);
 
       for (let i in prefObj.mailIdentities) {
@@ -194,20 +209,19 @@ var EnigmailConfigBackup = {
       let am = this.getAccountManager();
       am.saveAccountInfo();
       EnigmailPrefs.savePrefs();
 
       if ("rules" in prefObj) {
         EnigmailRules.loadRulesFromString(prefObj.rules);
         EnigmailRules.saveRulesFile();
       }
-
-    }
-    catch (ex) {
-      EnigmailLog.ERROR("configBackup.jsm: restorePrefs - exception " + ex.toString() + "\n");
+    } catch (ex) {
+      EnigmailLog.ERROR(
+        "configBackup.jsm: restorePrefs - exception " + ex.toString() + "\n"
+      );
       return returnObj;
     }
 
     returnObj.retVal = 0;
     return returnObj;
-  }
-
+  },
 };